Skip to content

Use ptr#NAME whenever the return value is stored #2645

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
uklotzde merged 1 commit into from
Apr 11, 2020
Merged

Use ptr#NAME whenever the return value is stored #2645

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
246 changes: 128 additions & 118 deletions src/test/trackmetadata_test.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -65,163 +65,173 @@ TEST_F(TrackMetadataTest, parseArtistTitleFromFileName) {
TEST_F(TrackMetadataTest, mergeImportedMetadata) {
// Existing track metadata (stored in the database) without extra properties
mixxx::TrackRecord oldTrackRecord;
mixxx::TrackMetadata& oldTrackMetadata = oldTrackRecord.refMetadata();
oldTrackMetadata.setBitrate(mixxx::audio::Bitrate(100));
oldTrackMetadata.setChannelCount(mixxx::audio::ChannelCount(1));
oldTrackMetadata.setDuration(mixxx::Duration::fromSeconds(60));
oldTrackMetadata.setSampleRate(mixxx::audio::SampleRate(10000));
mixxx::TrackInfo& oldTrackInfo = oldTrackMetadata.refTrackInfo();
oldTrackInfo.setArtist("old artist");
oldTrackInfo.setBpm(mixxx::Bpm(100));
oldTrackInfo.setComment("old comment");
oldTrackInfo.setComposer("old composer");
oldTrackInfo.setGenre("old genre");
oldTrackInfo.setGrouping("old grouping");
oldTrackInfo.setKey("1A");
oldTrackInfo.setReplayGain(mixxx::ReplayGain(0.1, 1));
oldTrackInfo.setTitle("old title");
oldTrackInfo.setTrackNumber("1");
oldTrackInfo.setTrackTotal("10");
oldTrackInfo.setYear("2001-01-01");
mixxx::AlbumInfo& oldAlbumInfo = oldTrackMetadata.refAlbumInfo();
oldAlbumInfo.setArtist("old album artist");
oldAlbumInfo.setTitle("old album title");
mixxx::TrackMetadata* pOldTrackMetadata = oldTrackRecord.ptrMetadata();
Copy link
Copy Markdown
Contributor

@uklotzde uklotzde Apr 10, 2020

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Why all those changes???

pOldTrackMetadata->setBitrate(mixxx::audio::Bitrate(100));
pOldTrackMetadata->setChannelCount(mixxx::audio::ChannelCount(1));
pOldTrackMetadata->setDuration(mixxx::Duration::fromSeconds(60));
pOldTrackMetadata->setSampleRate(mixxx::audio::SampleRate(10000));
mixxx::TrackInfo* pOldTrackInfo = pOldTrackMetadata->ptrTrackInfo();
pOldTrackInfo->setArtist("old artist");
pOldTrackInfo->setBpm(mixxx::Bpm(100));
pOldTrackInfo->setComment("old comment");
pOldTrackInfo->setComposer("old composer");
pOldTrackInfo->setGenre("old genre");
pOldTrackInfo->setGrouping("old grouping");
pOldTrackInfo->setKey("1A");
pOldTrackInfo->setReplayGain(mixxx::ReplayGain(0.1, 1));
pOldTrackInfo->setTitle("old title");
pOldTrackInfo->setTrackNumber("1");
pOldTrackInfo->setTrackTotal("10");
pOldTrackInfo->setYear("2001-01-01");
mixxx::AlbumInfo* pOldAlbumInfo = pOldTrackMetadata->ptrAlbumInfo();
pOldAlbumInfo->setArtist("old album artist");
pOldAlbumInfo->setTitle("old album title");

// Imported track metadata (from file tags) with extra properties
mixxx::TrackMetadata newTrackMetadata;
newTrackMetadata.setBitrate(mixxx::audio::Bitrate(200));
newTrackMetadata.setChannelCount(mixxx::audio::ChannelCount(2));
newTrackMetadata.setDuration(mixxx::Duration::fromSeconds(120));
newTrackMetadata.setSampleRate(mixxx::audio::SampleRate(20000));
mixxx::TrackInfo& newTrackInfo = newTrackMetadata.refTrackInfo();
newTrackInfo.setArtist("new artist");
newTrackInfo.setBpm(mixxx::Bpm(200));
newTrackInfo.setComment("new comment");
newTrackInfo.setComposer("new composer");
mixxx::TrackInfo* pNewTrackInfo = newTrackMetadata.ptrTrackInfo();
pNewTrackInfo->setArtist("new artist");
pNewTrackInfo->setBpm(mixxx::Bpm(200));
pNewTrackInfo->setComment("new comment");
pNewTrackInfo->setComposer("new composer");
#if defined(__EXTRA_METADATA__)
newTrackInfo.setConductor("new conductor");
newTrackInfo.setDiscNumber("1");
newTrackInfo.setDiscTotal("2");
newTrackInfo.setEncoder("encoder");
newTrackInfo.setEncoderSettings("encoder settings");
pNewTrackInfo->setConductor("new conductor");
pNewTrackInfo->setDiscNumber("1");
pNewTrackInfo->setDiscTotal("2");
pNewTrackInfo->setEncoder("encoder");
pNewTrackInfo->setEncoderSettings("encoder settings");
#endif // __EXTRA_METADATA__
newTrackInfo.setGenre("new genre");
newTrackInfo.setGrouping("new grouping");
pNewTrackInfo->setGenre("new genre");
pNewTrackInfo->setGrouping("new grouping");
#if defined(__EXTRA_METADATA__)
newTrackInfo.setISRC("isrc");
pNewTrackInfo->setISRC("isrc");
#endif // __EXTRA_METADATA__
newTrackInfo.setKey("1A");
pNewTrackInfo->setKey("1A");
#if defined(__EXTRA_METADATA__)
newTrackInfo.setLanguage("language");
newTrackInfo.setLyricist("lyricist");
newTrackInfo.setMood("mood");
newTrackInfo.setMovement("movement");
newTrackInfo.setMusicBrainzArtistId(QUuid("11111111-1111-1111-1111-111111111111"));
newTrackInfo.setMusicBrainzRecordingId(QUuid("22222222-2222-2222-2222-222222222222"));
newTrackInfo.setMusicBrainzReleaseId(QUuid("33333333-3333-3333-3333-333333333333"));
newTrackInfo.setMusicBrainzWorkId(QUuid("44444444-4444-4444-4444-444444444444"));
newTrackInfo.setRemixer("remixer");
pNewTrackInfo->setLanguage("language");
pNewTrackInfo->setLyricist("lyricist");
pNewTrackInfo->setMood("mood");
pNewTrackInfo->setMovement("movement");
pNewTrackInfo->setMusicBrainzArtistId(QUuid("11111111-1111-1111-1111-111111111111"));
pNewTrackInfo->setMusicBrainzRecordingId(QUuid("22222222-2222-2222-2222-222222222222"));
pNewTrackInfo->setMusicBrainzReleaseId(QUuid("33333333-3333-3333-3333-333333333333"));
pNewTrackInfo->setMusicBrainzWorkId(QUuid("44444444-4444-4444-4444-444444444444"));
pNewTrackInfo->setRemixer("remixer");
#endif // __EXTRA_METADATA__
newTrackInfo.setReplayGain(mixxx::ReplayGain(0.2, 2));
newTrackInfo.setTitle("new title");
newTrackInfo.setTrackNumber("2");
newTrackInfo.setTrackTotal("20");
pNewTrackInfo->setReplayGain(mixxx::ReplayGain(0.2, 2));
pNewTrackInfo->setTitle("new title");
pNewTrackInfo->setTrackNumber("2");
pNewTrackInfo->setTrackTotal("20");
#if defined(__EXTRA_METADATA__)
newTrackInfo.setWork("work");
#endif // __EXTRA_METADATA__
newTrackInfo.setYear("2002-02-02");
mixxx::AlbumInfo& newAlbumInfo = newTrackMetadata.refAlbumInfo();
newAlbumInfo.setArtist("new album artist");
pNewTrackInfo->setYear("2002-02-02");
mixxx::AlbumInfo* pNewAlbumInfo = newTrackMetadata.ptrAlbumInfo();
pNewAlbumInfo->setArtist("new album artist");
#if defined(__EXTRA_METADATA__)
newAlbumInfo.setCopyright("copyright");
newAlbumInfo.setLicense("license");
newAlbumInfo.setMusicBrainzArtistId(QUuid("55555555-5555-5555-5555-555555555555"));
newAlbumInfo.setMusicBrainzReleaseGroupId(QUuid("66666666-6666-6666-6666-666666666666"));
newAlbumInfo.setMusicBrainzReleaseId(QUuid("77777777-7777-7777-7777-777777777777"));
newAlbumInfo.setRecordLabel("copyright");
newAlbumInfo.setReplayGain(mixxx::ReplayGain(0.3, 3));
pNewAlbumInfo->setCopyright("copyright");
pNewAlbumInfo->setLicense("license");
pNewAlbumInfo->setMusicBrainzArtistId(QUuid("55555555-5555-5555-5555-555555555555"));
pNewAlbumInfo->setMusicBrainzReleaseGroupId(QUuid("66666666-6666-6666-6666-666666666666"));
pNewAlbumInfo->setMusicBrainzReleaseId(QUuid("77777777-7777-7777-7777-777777777777"));
pNewAlbumInfo->setRecordLabel("copyright");
pNewAlbumInfo->> setReplayGain(mixxx::ReplayGain(0.3, 3));
#endif // __EXTRA_METADATA__
newAlbumInfo.setTitle("new album title");
pNewAlbumInfo->setTitle("new album title");

mixxx::TrackRecord mergedTrackRecord = oldTrackRecord;
ASSERT_EQ(mergedTrackRecord.getMetadata(), oldTrackRecord.getMetadata());
ASSERT_NE(newTrackMetadata, oldTrackMetadata);
ASSERT_NE(newTrackMetadata, *pOldTrackMetadata);
mergedTrackRecord.mergeImportedMetadata(newTrackMetadata);

mixxx::TrackMetadata& mergedTrackMetadata = mergedTrackRecord.refMetadata();
EXPECT_EQ(oldTrackMetadata.getBitrate(), mergedTrackMetadata.getBitrate());
EXPECT_EQ(oldTrackMetadata.getChannelCount(), mergedTrackMetadata.getChannelCount());
EXPECT_EQ(oldTrackMetadata.getDuration(), mergedTrackMetadata.getDuration());
EXPECT_EQ(oldTrackMetadata.getSampleRate(), mergedTrackMetadata.getSampleRate());
mixxx::TrackInfo& mergedTrackInfo = mergedTrackMetadata.refTrackInfo();
EXPECT_EQ(oldTrackInfo.getArtist(), mergedTrackInfo.getArtist());
EXPECT_EQ(oldTrackInfo.getBpm(), mergedTrackInfo.getBpm());
EXPECT_EQ(oldTrackInfo.getComment(), mergedTrackInfo.getComment());
EXPECT_EQ(oldTrackInfo.getComposer(), mergedTrackInfo.getComposer());
mixxx::TrackMetadata* pMergedTrackMetadata = mergedTrackRecord.ptrMetadata();
EXPECT_EQ(pOldTrackMetadata->getBitrate(), pMergedTrackMetadata->getBitrate());
EXPECT_EQ(pOldTrackMetadata->getChannelCount(), pMergedTrackMetadata->getChannelCount());
EXPECT_EQ(pOldTrackMetadata->getDuration(), pMergedTrackMetadata->getDuration());
EXPECT_EQ(pOldTrackMetadata->getSampleRate(), pMergedTrackMetadata->getSampleRate());
mixxx::TrackInfo* pMergedTrackInfo = pMergedTrackMetadata->ptrTrackInfo();
EXPECT_EQ(pOldTrackInfo->getArtist(), pMergedTrackInfo->getArtist());
EXPECT_EQ(pOldTrackInfo->getBpm(), pMergedTrackInfo->getBpm());
EXPECT_EQ(pOldTrackInfo->getComment(), pMergedTrackInfo->getComment());
EXPECT_EQ(pOldTrackInfo->getComposer(), pMergedTrackInfo->getComposer());
#if defined(__EXTRA_METADATA__)
EXPECT_EQ(newTrackInfo.getConductor(), mergedTrackInfo.getConductor());
EXPECT_EQ(newTrackInfo.getDiscNumber(), mergedTrackInfo.getDiscNumber());
EXPECT_EQ(newTrackInfo.getDiscTotal(), mergedTrackInfo.getDiscTotal());
EXPECT_EQ(newTrackInfo.getEncoder(), mergedTrackInfo.getEncoder());
EXPECT_EQ(newTrackInfo.getEncoderSettings(), mergedTrackInfo.getEncoderSettings());
EXPECT_EQ(pNewTrackInfo->getConductor(), pMergedTrackInfo->getConductor());
EXPECT_EQ(pNewTrackInfo->getDiscNumber(), pMergedTrackInfo->getDiscNumber());
EXPECT_EQ(pNewTrackInfo->getDiscTotal(), pMergedTrackInfo->getDiscTotal());
EXPECT_EQ(pNewTrackInfo->getEncoder(), pMergedTrackInfo->getEncoder());
EXPECT_EQ(pNewTrackInfo->getEncoderSettings(), pMergedTrackInfo->getEncoderSettings());
#endif // __EXTRA_METADATA__
EXPECT_EQ(oldTrackInfo.getGenre(), mergedTrackInfo.getGenre());
EXPECT_EQ(oldTrackInfo.getGrouping(), mergedTrackInfo.getGrouping());
EXPECT_EQ(pOldTrackInfo->getGenre(), pMergedTrackInfo->getGenre());
EXPECT_EQ(pOldTrackInfo->getGrouping(), pMergedTrackInfo->getGrouping());
#if defined(__EXTRA_METADATA__)
EXPECT_EQ(newTrackInfo.getISRC(), mergedTrackInfo.getISRC());
EXPECT_EQ(pNewTrackInfo->getISRC(), pMergedTrackInfo->getISRC());
#endif // __EXTRA_METADATA__
EXPECT_EQ(oldTrackInfo.getKey(), mergedTrackInfo.getKey());
EXPECT_EQ(pOldTrackInfo->getKey(), pMergedTrackInfo->getKey());
#if defined(__EXTRA_METADATA__)
EXPECT_EQ(newTrackInfo.getLanguage(), mergedTrackInfo.getLanguage());
EXPECT_EQ(newTrackInfo.getLyricist(), mergedTrackInfo.getLyricist());
EXPECT_EQ(newTrackInfo.getMood(), mergedTrackInfo.getMood());
EXPECT_EQ(newTrackInfo.getMovement(), mergedTrackInfo.getMovement());
EXPECT_EQ(newTrackInfo.getMusicBrainzArtistId(), mergedTrackInfo.getMusicBrainzArtistId());
EXPECT_EQ(newTrackInfo.getMusicBrainzRecordingId(), mergedTrackInfo.getMusicBrainzRecordingId());
EXPECT_EQ(newTrackInfo.getMusicBrainzReleaseId(), mergedTrackInfo.getMusicBrainzReleaseId());
EXPECT_EQ(newTrackInfo.getMusicBrainzWorkId(), mergedTrackInfo.getMusicBrainzWorkId());
EXPECT_EQ(newTrackInfo.getRemixer(), mergedTrackInfo.getRemixer());
EXPECT_EQ(pNewTrackInfo->getLanguage(), pMergedTrackInfo->getLanguage());
EXPECT_EQ(pNewTrackInfo->getLyricist(), pMergedTrackInfo->getLyricist());
EXPECT_EQ(pNewTrackInfo->getMood(), pMergedTrackInfo->getMood());
EXPECT_EQ(pNewTrackInfo->getMovement(), pMergedTrackInfo->getMovement());
EXPECT_EQ(pNewTrackInfo->getMusicBrainzArtistId(), pMergedTrackInfo->getMusicBrainzArtistId());
EXPECT_EQ(pNewTrackInfo->getMusicBrainzRecordingId(),
pMergedTrackInfo->getMusicBrainzRecordingId());
EXPECT_EQ(pNewTrackInfo->getMusicBrainzReleaseId(),
pMergedTrackInfo->getMusicBrainzReleaseId());
EXPECT_EQ(pNewTrackInfo->getMusicBrainzWorkId(),
pMergedTrackInfo->getMusicBrainzWorkId());
EXPECT_EQ(pNewTrackInfo->getRemixer(), pMergedTrackInfo->getRemixer());
#endif // __EXTRA_METADATA__
EXPECT_EQ(oldTrackInfo.getReplayGain(), mergedTrackInfo.getReplayGain());
EXPECT_EQ(oldTrackInfo.getTitle(), mergedTrackInfo.getTitle());
EXPECT_EQ(oldTrackInfo.getTrackNumber(), mergedTrackInfo.getTrackNumber());
EXPECT_EQ(oldTrackInfo.getTrackTotal(), mergedTrackInfo.getTrackTotal());
EXPECT_EQ(
pOldTrackInfo->getReplayGain(), pMergedTrackInfo->getReplayGain());
EXPECT_EQ(pOldTrackInfo->getTitle(), pMergedTrackInfo->getTitle());
EXPECT_EQ(pOldTrackInfo->getTrackNumber(),
pMergedTrackInfo->getTrackNumber());
EXPECT_EQ(
pOldTrackInfo->getTrackTotal(), pMergedTrackInfo->getTrackTotal());
#if defined(__EXTRA_METADATA__)
EXPECT_EQ(newTrackInfo.getWork(), mergedTrackInfo.getWork());
EXPECT_EQ(pNewTrackInfo.getWork(), pMergedTrackInfo->getWork());
#endif // __EXTRA_METADATA__
EXPECT_EQ(oldTrackInfo.getYear(), mergedTrackInfo.getYear());
mixxx::AlbumInfo& mergedAlbumInfo = mergedTrackMetadata.refAlbumInfo();
EXPECT_EQ(oldAlbumInfo.getArtist(), mergedAlbumInfo.getArtist());
EXPECT_EQ(pOldTrackInfo->getYear(), pMergedTrackInfo->getYear());
mixxx::AlbumInfo* pMergedAlbumInfo =
pMergedTrackMetadata->ptrAlbumInfo();
EXPECT_EQ(pOldAlbumInfo->getArtist(), pMergedAlbumInfo->getArtist());
#if defined(__EXTRA_METADATA__)
EXPECT_EQ(newAlbumInfo.getCopyright(), mergedAlbumInfo.getCopyright());
EXPECT_EQ(newAlbumInfo.getLicense(), mergedAlbumInfo.getLicense());
EXPECT_EQ(newAlbumInfo.getMusicBrainzArtistId(), mergedAlbumInfo.getMusicBrainzArtistId());
EXPECT_EQ(newAlbumInfo.getMusicBrainzReleaseGroupId(), mergedAlbumInfo.getMusicBrainzReleaseGroupId());
EXPECT_EQ(newAlbumInfo.getMusicBrainzReleaseId(), mergedAlbumInfo.getMusicBrainzReleaseId());
EXPECT_EQ(newAlbumInfo.getRecordLabel(), mergedAlbumInfo.getRecordLabel());
EXPECT_EQ(newAlbumInfo.getReplayGain(), mergedAlbumInfo.getReplayGain());
EXPECT_EQ(pNewAlbumInfo->getCopyright(), pMergedAlbumInfo->getCopyright());
EXPECT_EQ(pNewAlbumInfo->getLicense(), pMergedAlbumInfo->getLicense());
EXPECT_EQ(pNewAlbumInfo->getMusicBrainzArtistId(),
pMergedAlbumInfo->getMusicBrainzArtistId());
EXPECT_EQ(pNewAlbumInfo->getMusicBrainzReleaseGroupId(),
pMergedAlbumInfo->getMusicBrainzReleaseGroupId());
EXPECT_EQ(pNewAlbumInfo->getMusicBrainzReleaseId(),
pMergedAlbumInfo->getMusicBrainzReleaseId());
EXPECT_EQ(pNewAlbumInfo->getRecordLabel(), pMergedAlbumInfo->getRecordLabel());
EXPECT_EQ(pNewAlbumInfo->getReplayGain(), pMergedAlbumInfo->getReplayGain());
#endif // __EXTRA_METADATA__
EXPECT_EQ(oldAlbumInfo.getTitle(), mergedAlbumInfo.getTitle());
EXPECT_EQ(pOldAlbumInfo->getTitle(), pMergedAlbumInfo->getTitle());

// Check that all existing properties are preserved, even if empty or missing
mergedTrackInfo.setArtist("");
mergedTrackInfo.setTitle(QString());
mergedAlbumInfo.setArtist("");
mergedAlbumInfo.setTitle(QString());
pMergedTrackInfo->setArtist("");
pMergedTrackInfo->setTitle(QString());
pMergedAlbumInfo->setArtist("");
pMergedAlbumInfo->setTitle(QString());
mergedTrackRecord.mergeImportedMetadata(newTrackMetadata);
EXPECT_EQ(QString(""), mergedTrackInfo.getArtist());
EXPECT_EQ(QString(), mergedTrackInfo.getTitle());
EXPECT_EQ(QString(""), mergedAlbumInfo.getArtist());
EXPECT_EQ(QString(), mergedAlbumInfo.getTitle());
EXPECT_EQ(QString(""), pMergedTrackInfo->getArtist());
EXPECT_EQ(QString(), pMergedTrackInfo->getTitle());
EXPECT_EQ(QString(""), pMergedAlbumInfo->getArtist());
EXPECT_EQ(QString(), pMergedAlbumInfo->getTitle());

// Check that the placeholder for track total is replaced with the actual property
ASSERT_NE(mixxx::TrackRecord::kTrackTotalPlaceholder, newTrackInfo.getTrackTotal());
mergedTrackInfo.setTrackTotal(mixxx::TrackRecord::kTrackTotalPlaceholder);
ASSERT_NE(mixxx::TrackRecord::kTrackTotalPlaceholder, pNewTrackInfo->getTrackTotal());
pMergedTrackInfo->setTrackTotal(mixxx::TrackRecord::kTrackTotalPlaceholder);
mergedTrackRecord.mergeImportedMetadata(newTrackMetadata);
EXPECT_EQ(newTrackInfo.getTrackTotal(), mergedTrackInfo.getTrackTotal());
EXPECT_EQ(pNewTrackInfo->getTrackTotal(), pMergedTrackInfo->getTrackTotal());
// ...but if track total is missing entirely it should be preserved
ASSERT_NE(QString(), newTrackInfo.getTrackTotal());
mergedTrackInfo.setTrackTotal(QString());
ASSERT_NE(QString(), pNewTrackInfo->getTrackTotal());
pMergedTrackInfo->setTrackTotal(QString());
mergedTrackRecord.mergeImportedMetadata(newTrackMetadata);
EXPECT_EQ(QString(), mergedTrackInfo.getTrackTotal());
EXPECT_EQ(QString(), pMergedTrackInfo->getTrackTotal());
}
Loading