def test_get_columns_migrated(self):
     self.failIf(config.get("settings", "headers", None))
     columns = "~album,~#replaygain_track_gain,foobar"
     config.set("settings", "columns", columns)
     self.failUnlessEqual(get_columns(),
                          ["~album", "~#replaygain_track_gain", "foobar"])
     self.failIf(config.get("settings", "headers", None))

def finish_first_session(app_name):
    """Call on shutdown so that is_first_session() works"""

    from quodlibet import config
    from quodlibet import const

    config.set("memory", "%s_last_active_version" % app_name, const.VERSION)

    def test_moveart_multi_source(self):
        self.reset_environment()
        config.set("rename", "move_art", True)
        config.set("albumart", "search_filenames", "*.jpg")

        source, target = \
            self.source_target(self.root_path, 'artist', 'album')
        source2, target2 = \
            self.source_target(self.root_path, 'artist', 'album2')

        self.filenames = ['art.jpg']
        self.art_set(source)
        self.filenames = ['art2.jpg']
        self.art_set(source2)

        song_files, songs = self.song_set(source)
        song_files2, songs2 = self.song_set(source2)

        self.renamer.add_songs(songs + songs2)

        # avoid audio file clashes
        pattern = os.path.join(target, '[<album>] artist - <title>')
        self.renamer.rename(pattern, songs + songs2)

        # album art sets merged
        count_expected = 2
        self.moveart_set()
        target_files = glob.glob(os.path.join(target, '*.jpg'))
        count_target = len(target_files)
        self.failUnlessEqual(count_target, count_expected)

    def test_get_cover_many_prefer_embedded(self):
        # embed one cover, move one to the other dir
        MP3File(self.file1).set_image(EmbeddedImage.from_path(self.cover1))
        os.unlink(self.cover1)
        self.external_cover = os.path.join(self.dir2, "cover.png")
        shutil.move(self.cover2, self.external_cover)

        # move one audio file in each dir
        shutil.move(self.file1, self.dir1)
        self.file1 = os.path.join(self.dir1, os.path.basename(self.file1))
        shutil.move(self.file2, self.dir2)
        self.file2 = os.path.join(self.dir2, os.path.basename(self.file2))

        song1 = MP3File(self.file1)
        song2 = MP3File(self.file2)

        # each should find a cover
        self.failUnless(self.is_embedded(self.manager.get_cover(song1)))
        self.failIf(self.is_embedded(self.manager.get_cover(song2)))

        cover_for = self.manager.get_cover_many
        # both settings should search both songs before giving up
        config.set("albumart", "prefer_embedded", True)
        self.failUnless(self.is_embedded(cover_for([song1, song2])))
        self.failUnless(self.is_embedded(cover_for([song2, song1])))

        config.set("albumart", "prefer_embedded", False)
        self.failIf(self.is_embedded(cover_for([song1, song2])))
        self.failIf(self.is_embedded(cover_for([song2, song1])))

    def __changed_entry(self, entry, cbs, label):
        text = entry.get_text()
        if text[0:1] == "<" and text[-1:] == ">":
            parts = text[1:-1].split("~")
            for cb in cbs:
                if parts and parts[0] == cb.tag:
                    parts.pop(0)
            if parts:
                for cb in cbs:
                    cb.set_inconsistent(True)
            else:
                parts = text[1:-1].split("~")
                for cb in cbs:
                    cb.set_inconsistent(False)
                    cb.set_active(cb.tag in parts)
        else:
            for cb in cbs:
                cb.set_inconsistent(True)

        if app.player.info is None:
            text = _("Not playing")
        else:
            text = Pattern(entry.get_text()) % app.player.info
        label.set_text(text)
        label.get_parent().set_tooltip_text(text)
        config.set("plugins", "icon_tooltip", entry.get_text())

 def set_band(adj, idx):
     rounded = int(adj.get_value() * 2) / 2.0
     adj.set_value(rounded)
     levels[idx] = rounded
     config.set('plugins', 'equalizer_levels',
                ','.join(str(lv) for lv in levels))
     self.apply()

 def setUp(self):
     self.mod = self.modules[DownloadCoverArt.PLUGIN_ID]
     self.songs = [A_SONG]
     config.add_section(PluginManager.CONFIG_SECTION)
     config.set(PluginManager.CONFIG_SECTION,
                '%s_preview_size' % DownloadCoverArt.PLUGIN_ID,
                200)

 def test_default_email_rating(self):
     self.song["~#rating"] = 0.2
     self.song.write()
     song = type(self.song)(self.filename)
     config.set("editing", "save_email", "[email protected]")
     config.set("editing", "save_email", const.EMAIL)
     self.failUnlessEqual(song["~#rating"], 0.2)

 def __changed_and_signal_library(self, entry, section, name):
     config.set(section, name, str(entry.get_value()))
     print_d("Signalling \"changed\" to entire library. Hold tight...")
     # Cache over clicks
     self._songs = self._songs or app.library.values()
     copool.add(emit_signal, self._songs, funcid="library changed",
                name=_("Updating for new ratings"))

 def __visible(self, cb, prop, menu, clear):
     value = self.get_property('visible')
     config.set("memory", "queue", str(value))
     menu.set_active(value)
     self.set_expanded(not self.model.is_empty())
     cb.set_property('visible', self.get_expanded())
     clear.set_property('visible', self.get_expanded())

 def test_glob(self):
     config.set("albumart", "force_filename", str(True))
     config.set("albumart", "filename", "foo.*")
     for fn in ["foo.jpg", "foo.png"]:
         f = self.add_file(fn)
         assert path_equal(
             os.path.abspath(self._find_cover(self.song).name), f)

 def test_dont_save(self):
     config.set("editing", "save_to_songs", "false")
     self.song["~#rating"] = 1.0
     self.song.write()
     song = type(self.song)(self.filename)
     config.set("editing", "save_to_songs", "true")
     self.failUnlessEqual(song("~#rating"), const.DEFAULT_RATING)

 def bool_changed(widget):
     """Boolean setting changed."""
     if widget.get_active():
         setattr(self.configuration, widget.get_name(), True)
     else:
         setattr(self.configuration, widget.get_name(), False)
     config.set("plugins", "autoqueue_%s" % widget.get_name(), widget.get_active() and "true" or "false")

    def setUp(self):
        config.init()
        config.set("player", "gst_pipeline", "fakesink")
        config.set("settings", "xine_driver", "none")
        module = player.init_backend(self.NAME)
        lib = library.init()
        self.player = module.init(lib.librarian)
        source = PlaylistModel()
        source.set(FILES)

        self.events = []

        def start_end_handler(player, song, *args):
            self.events.append((args[-1], song))

        self.player.connect("song-started", start_end_handler, "started")
        self.player.connect("song-ended", start_end_handler, "ended")

        self.player.setup(source, None, 0)

        self.signals = []

        def handler(type_, *args):
            self.signals.append(type_)
        connect_obj(self.player, "unpaused", handler, "unpaused")
        connect_obj(self.player, "paused", handler, "paused")

 def test_restore(self):
     config.set("browsers", "query_text", "foo")
     self.bar.restore()
     self.failUnlessEqual(self.bar._get_text(), "foo")
     self.bar.finalize(True)
     self._wait()
     self.failUnlessEqual(self.emit_count, 0)

    def test_acquire_prefer_embedded(self):
        # embed one cover...
        MP3File(self.file1).set_image(EmbeddedImage.from_path(self.cover1))
        os.unlink(self.cover1)
        self.external_cover = os.path.join(self.dir1, "cover.png")
        # ...and save a different cover externally
        shutil.copy(self.cover2, self.external_cover)

        shutil.move(self.file1, self.dir1)
        self.file1 = os.path.join(self.dir1, os.path.basename(self.file1))
        both_song = MP3File(self.file1)

        results = []

        def acquire(song):
            def cb(source, result):
                results.append(result)

            self.manager.acquire_cover(cb, None, song)

        def result_was_embedded():
            return self.is_embedded(results.pop())

        config.set("albumart", "prefer_embedded", True)
        acquire(both_song)
        self.failUnless(result_was_embedded(),
                        "Embedded image expected due to prefs")

        config.set("albumart", "prefer_embedded", False)
        acquire(both_song)
        self.failIf(result_was_embedded(),
                    "Got an embedded image despite prefs")

 def test_toggle(self):
     config.set("memory", "bar", "on")
     c = ConfigCheckMenuItem("dummy", "memory", "bar")
     c.set_active(True)
     self.failUnless(config.getboolean("memory", "bar") and c.get_active())
     c.set_active(False)
     while gtk.events_pending(): gtk.main_iteration()
     self.failIf(config.getboolean("memory", "bar") or c.get_active())

    def __do_save_size_pos(self, width, height):
        if self.__state & Gdk.WindowState.MAXIMIZED:
            return

        value = "%d %d" % (width, height)
        config.set("memory", self.__conf("size"), value)

        self.__do_save_pos()

 def __cols_changed(self, songlist):
     headers = [col.header_name for col in songlist.get_columns()]
     try: headers.remove('~current')
     except ValueError: pass
     if len(headers) == len(config.get("settings", "headers").split()):
         # Not an addition or removal (handled separately)
         config.set("settings", "headers", " ".join(headers))
         SongList.headers = headers

 def _turn_all_options_on(self):
     for name in ['REMOVE_WHITESPACE', 'REMOVE_DIACRITICS',
                  'REMOVE_PUNCTUATION', 'CASE_INSENSITIVE']:
         # Get the actual values, don't hard-code here (kinda)
         cfg_name = getattr(self.mod.Duplicates, "_CFG_%s" % name)
         config.set(PM.CONFIG_SECTION,
                    self.kind._get_config_option(cfg_name),
                    True)