File indexing completed on 2024-06-23 04:45:52

 /***************************************************************************
  *   Copyright (c) 2009 Sven Krohlas <sven@asbest-online.de>               *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
 #include "TestMetaMultiTrack.h"
 
 #include "core/support/Components.h"
 #include "EngineController.h"
 #include "config-amarok-test.h"
 #include "core-impl/collections/support/CollectionManager.h"
 #include "core-impl/meta/multi/MultiTrack.h"
 #include "core-impl/playlists/types/file/PlaylistFileSupport.h"
 
 #include <QDir>
 #include <QFileInfo>
 #include <QSignalSpy>
 #include <QTest>
 #include <QTimer>
 
 #include <ThreadWeaver/Queue>
 
 QTEST_GUILESS_MAIN( TestMetaMultiTrack )
 
 TestMetaMultiTrack::TestMetaMultiTrack()
     : m_testMultiTrack( nullptr )
 {
 }
 
 void
 TestMetaMultiTrack::tracksLoaded( Playlists::PlaylistPtr playlist )
 {
     emit tracksLoadedSignal( playlist );
 }
 
 void TestMetaMultiTrack::initTestCase()
 {
     qRegisterMetaType<Meta::TrackPtr>( "Meta::TrackPtr" );
 
     //apparently the engine controller is needed somewhere, or we will get a crash...
     EngineController *controller = new EngineController();
     Amarok::Components::setEngineController( controller );
 
     /* Collection manager needs to be instantiated in the main thread, but
      * MetaProxy::Tracks used by playlist may trigger its creation in a different thread.
      * Pre-create it explicitly */
     CollectionManager::instance();
 
     const QString path = QString( AMAROK_TEST_DIR ) + "/data/playlists/test.pls";
     const QFileInfo file( QDir::toNativeSeparators( path ) );
     QVERIFY( file.exists() );
     const QString filePath = file.absoluteFilePath();
     m_playlist = Playlists::loadPlaylistFile( QUrl::fromLocalFile(filePath) ).data();
     QVERIFY( m_playlist ); // no playlist -> no test. that's life ;)
     subscribeTo( m_playlist );
     m_playlist->triggerTrackLoad();
     QSignalSpy spy( this, &TestMetaMultiTrack::tracksLoadedSignal );
     if( m_playlist->trackCount() < 0 )
         QVERIFY( spy.wait( 5000 ) );
 
     QCOMPARE( m_playlist->name(), QString("test.pls") );
     QCOMPARE( m_playlist->trackCount(), 4 );
 
     // now wait for all MetaProxy::Tracks to actually load their real tracks:
     NotifyObserversWaiter wainter( m_playlist->tracks().toSet() );
     QSignalSpy spyDone( &wainter, &NotifyObserversWaiter::done );
     QVERIFY( spyDone.wait( 5000 ) );
 }
 
 void
 TestMetaMultiTrack::cleanupTestCase()
 {
     // Wait for other jobs, like MetaProxys fetching meta data, to finish
     ThreadWeaver::Queue::instance()->finish();
 }
 
 void TestMetaMultiTrack::init()
 {
     m_testMultiTrack = new Meta::MultiTrack( m_playlist );
 }
 
 void TestMetaMultiTrack::cleanup()
 {
     delete m_testMultiTrack;
 }
 
 void TestMetaMultiTrack::testSources()
 {
     QStringList sources = m_testMultiTrack->sources();
     QCOMPARE( sources.size(), 4 );
     QCOMPARE( sources.at( 0 ), QString( "http://85.214.44.27:8000" ) );
     QCOMPARE( sources.at( 1 ), QString( "http://217.20.121.40:8000" ) );
     QCOMPARE( sources.at( 2 ), QString( "http://85.214.44.27:8100" ) );
     QCOMPARE( sources.at( 3 ), QString( "http://85.214.44.27:8200" ) );
 }
 
 void TestMetaMultiTrack::testSetSourceCurrentNextUrl()
 {
     QCOMPARE( m_testMultiTrack->current(), 0 );
     QCOMPARE( m_testMultiTrack->playableUrl(), QUrl("http://85.214.44.27:8000") );
     QCOMPARE( m_testMultiTrack->nextUrl(), QUrl("http://217.20.121.40:8000") );
 
     m_testMultiTrack->setSource( 1 );
     QCOMPARE( m_testMultiTrack->current(), 1 );
     QCOMPARE( m_testMultiTrack->playableUrl(), QUrl("http://217.20.121.40:8000") );
     QCOMPARE( m_testMultiTrack->nextUrl(), QUrl("http://85.214.44.27:8100") );
 
     m_testMultiTrack->setSource( 2 );
     QCOMPARE( m_testMultiTrack->current(), 2 );
     QCOMPARE( m_testMultiTrack->playableUrl(), QUrl("http://85.214.44.27:8100") );
     QCOMPARE( m_testMultiTrack->nextUrl(), QUrl("http://85.214.44.27:8200") );
 
     m_testMultiTrack->setSource( 3 );
     QCOMPARE( m_testMultiTrack->current(), 3 );
     QCOMPARE( m_testMultiTrack->playableUrl(), QUrl("http://85.214.44.27:8200") );
     QCOMPARE( m_testMultiTrack->nextUrl(), QUrl() );
 
     m_testMultiTrack->setSource( 4 );
     QCOMPARE( m_testMultiTrack->current(), 3 );
     m_testMultiTrack->setSource( -1 );
     QCOMPARE( m_testMultiTrack->current(), 3 );
 }
 
 void TestMetaMultiTrack::testHasCapabilityInterface()
 {
     QVERIFY( m_testMultiTrack->hasCapabilityInterface( Capabilities::Capability::MultiSource ) );
 }
 
 NotifyObserversWaiter::NotifyObserversWaiter( const QSet<Meta::TrackPtr> &tracks, QObject *parent )
     : QObject( parent )
     , m_tracks( tracks )
 {
     // we need to filter already resolved tracks in the next event loop iteration because
     // the user wouldn't be able to get the done() signal yet.
     QTimer::singleShot( 0, this, &NotifyObserversWaiter::slotFilterResolved );
 }
 
 void
 NotifyObserversWaiter::slotFilterResolved()
 {
     QMutexLocker locker( &m_mutex );
     QMutableSetIterator<Meta::TrackPtr> it( m_tracks );
     while( it.hasNext() )
     {
         const Meta::TrackPtr &track = it.next();
         const MetaProxy::Track *proxyTrack = dynamic_cast<const MetaProxy::Track *>( track.data() );
         Q_ASSERT( proxyTrack );
         if( proxyTrack->isResolved() )
             it.remove();
         else
             subscribeTo( track );
     }
     if( m_tracks.isEmpty() )
         emit done();
 }
 
 void
 NotifyObserversWaiter::metadataChanged( Meta::TrackPtr track )
 {
     QMutexLocker locker( &m_mutex );
     m_tracks.remove( track );
     if( m_tracks.isEmpty() )
         emit done();
 }