chrome/utility/media_galleries/itunes_library_parser

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
CompareTrack
CompareAlbum
CompareAlbums
CompareLibrary
TestParser
AddExpectedTrack
TEST_F
TEST_F
TEST_F
TEST_F
TEST_F
TEST_F
TEST_F
TEST_F
TEST_F
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/logging.h"
#include "chrome/common/media_galleries/itunes_library.h"
#include "chrome/utility/media_galleries/itunes_library_parser.h"
#include "testing/gtest/include/gtest/gtest.h"

#define SIMPLE_HEADER()         \
    "<plist>"                   \
    "  <dict>"                  \
    "    <key>Tracks</key>"     \
    "    <dict>"

#define SIMPLE_TRACK(key, id, path, artist, album)                     \
    "<key>" #key "</key>"                                              \
    "<dict>"                                                           \
    "  <key>Track ID</key><integer>" #id "</integer>"                  \
    "  <key>Location</key><string>file://localhost/" path "</string>"  \
    "  <key>Artist</key><string>" artist "</string>"                   \
    "  <key>Album</key><string>" album "</string>"                     \
    "</dict>"

#define SIMPLE_FOOTER()  \
    "    </dict>"        \
    "  </dict>"          \
    "</plist>"

namespace itunes {

namespace {

void CompareTrack(const parser::Track& a, const parser::Track& b) {
  EXPECT_EQ(a.id, b.id);
  EXPECT_EQ(a.location.value(), b.location.value());
}

void CompareAlbum(const parser::Album& a, const parser::Album& b) {
  EXPECT_EQ(a.size(), b.size());

  parser::Album::const_iterator a_it;
  parser::Album::const_iterator b_it;
  for (a_it = a.begin(), b_it = b.begin();
       a_it != a.end() && b_it != b.end();
       ++a_it, ++b_it) {
    CompareTrack(*a_it, *b_it);
  }
}

void CompareAlbums(const parser::Albums& a, const parser::Albums& b) {
  EXPECT_EQ(a.size(), b.size());

  parser::Albums::const_iterator a_it;
  parser::Albums::const_iterator b_it;
  for (a_it = a.begin(), b_it = b.begin();
       a_it != a.end() && b_it != b.end();
       ++a_it, ++b_it) {
    EXPECT_EQ(a_it->first, b_it->first);
    CompareAlbum(a_it->second, b_it->second);
  }
}

void CompareLibrary(const parser::Library& a, const parser::Library& b) {
  EXPECT_EQ(a.size(), b.size());

  parser::Library::const_iterator a_it;
  parser::Library::const_iterator b_it;
  for (a_it = a.begin(), b_it = b.begin();
       a_it != a.end() && b_it != b.end();
       ++a_it, ++b_it) {
    EXPECT_EQ(a_it->first, b_it->first);
    CompareAlbums(a_it->second, b_it->second);
  }
}

class ITunesLibraryParserTest : public testing::Test {
 public:
  ITunesLibraryParserTest() {}

  void TestParser(bool expected_result, const std::string& xml) {
    ITunesLibraryParser parser;

    EXPECT_EQ(expected_result, parser.Parse(xml));
    if (!expected_result)
      return;

    CompareLibrary(expected_library_, parser.library());
  }

  void AddExpectedTrack(uint32 id, const std::string& location,
                        const std::string& artist, const std::string& album) {
    // On Mac this pretends that C: is a directory.
#if defined(OS_MACOSX)
    std::string os_location = "/" + location;
#else
    const std::string& os_location = location;
#endif
    parser::Track track(id, base::FilePath::FromUTF8Unsafe(os_location));
    expected_library_[artist][album].insert(track);
  }

 private:
  parser::Library expected_library_;

  DISALLOW_COPY_AND_ASSIGN(ITunesLibraryParserTest);
};

TEST_F(ITunesLibraryParserTest, EmptyLibrary) {
  TestParser(false, "");
}

TEST_F(ITunesLibraryParserTest, MinimalXML) {
  AddExpectedTrack(1, "C:/dir/Song With Space.mp3", "Artist A", "Album A");
  TestParser(
      true,
      SIMPLE_HEADER()
      SIMPLE_TRACK(1, 1, "C:/dir/Song%20With%20Space.mp3", "Artist A",
                   "Album A")
      SIMPLE_FOOTER());
}

TEST_F(ITunesLibraryParserTest, MultipleSongs) {
  AddExpectedTrack(1, "C:/dir/SongA1.mp3", "Artist A", "Album A");
  AddExpectedTrack(2, "C:/dir/SongA2.mp3", "Artist A", "Album A");
  AddExpectedTrack(3, "C:/dir/SongA3.mp3", "Artist A", "Album A");
  AddExpectedTrack(4, "C:/dir/SongB1.mp3", "Artist A", "Album B");
  AddExpectedTrack(5, "C:/dir/SongB2.mp3", "Artist A", "Album B");
  AddExpectedTrack(6, "C:/dir2/SongB1.mp3", "Artist B", "Album B");
  AddExpectedTrack(7, "C:/dir2/SongB2.mp3", "Artist B", "Album B");
  TestParser(
      true,
      SIMPLE_HEADER()
      SIMPLE_TRACK(1, 1, "C:/dir/SongA1.mp3", "Artist A", "Album A")
      SIMPLE_TRACK(2, 2, "C:/dir/SongA2.mp3", "Artist A", "Album A")
      SIMPLE_TRACK(3, 3, "C:/dir/SongA3.mp3", "Artist A", "Album A")
      SIMPLE_TRACK(4, 4, "C:/dir/SongB1.mp3", "Artist A", "Album B")
      SIMPLE_TRACK(5, 5, "C:/dir/SongB2.mp3", "Artist A", "Album B")
      SIMPLE_TRACK(6, 6, "C:/dir2/SongB1.mp3", "Artist B", "Album B")
      SIMPLE_TRACK(7, 7, "C:/dir2/SongB2.mp3", "Artist B", "Album B")
      SIMPLE_FOOTER());
}

TEST_F(ITunesLibraryParserTest, MismatchedId) {
  TestParser(
      false,
      SIMPLE_HEADER()
      SIMPLE_TRACK(1, 2, "C:/dir/SongA1.mp3", "Artist A", "Album A")
      SIMPLE_FOOTER());

  AddExpectedTrack(1, "C:/dir/SongA1.mp3", "Artist A", "Album A");
  TestParser(
      true,
      SIMPLE_HEADER()
      SIMPLE_TRACK(1, 1, "C:/dir/SongA1.mp3", "Artist A", "Album A")
      SIMPLE_TRACK(2, 3, "C:/dir/SongA2.mp3", "Artist A", "Album A")
      SIMPLE_FOOTER());
}

TEST_F(ITunesLibraryParserTest, OtherDictionaryEntries) {
  AddExpectedTrack(1, "C:/dir/SongA1.mp3", "Artist A", "Album A");
  TestParser(
      true,
      "<plist>"
      "  <dict>"
      "    <key>Other section</key>"
      "    <dict>"
      // In Other section, not Tracks.
      SIMPLE_TRACK(10, 10, "C:/dir/SongB2.mp3", "Artist B", "Album B")
      "    </dict>"
      "    <key>Tracks</key>"
      "    <dict>"
      "      <key>1</key>"
      "      <dict>"
      // In the body of a track dictionary before the interesting entries.
      SIMPLE_TRACK(20, 20, "C:/dir/SongB2.mp3", "Artist B", "Album B")
      // Entries in a different order.
      "        <key>Artist</key><string>Artist A</string>"
      "        <key>Location</key>"
      "          <string>file://localhost/C:/dir/SongA1.mp3</string>"
      "        <key>Album</key><string>Album A</string>"
      "        <key>Track ID</key><integer>1</integer>"
      // In the body of a track dictionary after the interesting entries.
      SIMPLE_TRACK(30, 30, "C:/dir/SongB3.mp3", "Artist B", "Album B")
      "      </dict>"
      "      <key>40</key>"
      "      <dict>"
      // Missing album name.
      "        <key>Artist</key><string>Artist B</string>"
      "        <key>Location</key>"
      "          <string>file://localhost/C:/dir/SongB4.mp3</string>"
      "        <key>Track ID</key><integer>1</integer>"
      "      </dict>"
      SIMPLE_FOOTER());
}

TEST_F(ITunesLibraryParserTest, MissingEntry) {
  AddExpectedTrack(1, "C:/dir/SongA1.mp3", "Artist A", "Album A");
  AddExpectedTrack(3, "C:/dir/SongA3.mp3", "Artist A", "Album A");
  TestParser(
      true,
      SIMPLE_HEADER()
      SIMPLE_TRACK(1, 1, "C:/dir/SongA1.mp3", "Artist A", "Album A")
      "<key>2</key><dict>"
      "  <key>Track ID</key><integer>2</integer>"
      "  <key>Album</key><string>Album A</string>"
      "  <key>Foo</key><string>Bar</string>"
      "   "  // A whitespace node is important for the test.
      "</dict>"
      SIMPLE_TRACK(3, 3, "C:/dir/SongA3.mp3", "Artist A", "Album A")
      SIMPLE_FOOTER());
}

TEST_F(ITunesLibraryParserTest, UnknownAlbumOrArtist) {
  AddExpectedTrack(1, "C:/dir/SongA1.mp3", "Artist A", "Unknown Album");
  AddExpectedTrack(2, "C:/dir/SongA2.mp3", "Unknown Artist", "Album A");
  AddExpectedTrack(3, "C:/dir/SongA3.mp3", "Unknown Artist", "Unknown Album");
  TestParser(
      true,
      SIMPLE_HEADER()
      "<key>1</key><dict>"
      "  <key>Track ID</key><integer>1</integer>"
      "  <key>Location</key><string>file://localhost/C:/dir/SongA1.mp3</string>"
      "  <key>Artist</key><string>Artist A</string>"
      "</dict>"
      "<key>2</key><dict>"
      "  <key>Track ID</key><integer>2</integer>"
      "  <key>Location</key><string>file://localhost/C:/dir/SongA2.mp3</string>"
      "  <key>Album</key><string>Album A</string>"
      "</dict>"
      "<key>3</key><dict>"
      "  <key>Track ID</key><integer>3</integer>"
      "  <key>Location</key><string>file://localhost/C:/dir/SongA3.mp3</string>"
      "</dict>"
      SIMPLE_FOOTER());
}

TEST_F(ITunesLibraryParserTest, AlbumArtist) {
  AddExpectedTrack(1, "C:/dir/SongA1.mp3", "Artist A", "Unknown Album");
  AddExpectedTrack(2, "C:/dir/SongA2.mp3", "Artist A", "Unknown Album");
  AddExpectedTrack(3, "C:/dir/SongA3.mp3", "Artist A", "Unknown Album");
  AddExpectedTrack(4, "C:/dir/SongA4.mp3", "Artist A", "Album");
  TestParser(
      true,
      SIMPLE_HEADER()
      "<key>1</key><dict>"
      "  <key>Track ID</key><integer>1</integer>"
      "  <key>Location</key><string>file://localhost/C:/dir/SongA1.mp3</string>"
      "  <key>Album Artist</key><string>Artist A</string>"
      "</dict>"
      "<key>2</key><dict>"
      "  <key>Track ID</key><integer>2</integer>"
      "  <key>Location</key><string>file://localhost/C:/dir/SongA2.mp3</string>"
      "  <key>Artist</key><string>Artist B</string>"
      "  <key>Album Artist</key><string>Artist A</string>"
      "</dict>"
      "<key>3</key><dict>"
      "  <key>Track ID</key><integer>3</integer>"
      "  <key>Location</key><string>file://localhost/C:/dir/SongA3.mp3</string>"
      "  <key>Album Artist</key><string>Artist A</string>"
      "  <key>Artist</key><string>Artist B</string>"
      "</dict>"
      "<key>4</key><dict>"
      "  <key>Track ID</key><integer>4</integer>"
      "  <key>Location</key><string>file://localhost/C:/dir/SongA4.mp3</string>"
      "  <key>Album</key><string>Album</string>"
      "  <key>Artist</key><string>Artist B</string>"
      "  <key>Album Artist</key><string>Artist A</string>"
      "</dict>"
      SIMPLE_FOOTER());
}

TEST_F(ITunesLibraryParserTest, MacPath) {
  AddExpectedTrack(1, "dir/Song With Space.mp3", "Artist A", "Album A");
  TestParser(
      true,
      SIMPLE_HEADER()
      // This path is concatenated with "http://localhost/", so no leading
      // slash should be used.
      SIMPLE_TRACK(1, 1, "dir/Song%20With%20Space.mp3", "Artist A", "Album A")
      SIMPLE_FOOTER());
}

}  // namespace

}  // namespace itunes
/* [<][>][^][v][top][bottom][index][help] */
root/chrome/utility/media_galleries/itunes_library_parser_unittest.cc

DEFINITIONS
