"experiment/src/contrib/PACKAGES",

          "https://www.bioconductor.org/packages/release/data/"

          "annotation/src/contrib/PACKAGES",

          "https://cran.r-project.org/src/contrib/PACKAGES",

          "https://r-forge.r-project.org/src/contrib/PACKAGES",

      ]

                  b_dir = True

              if (

                  rpm.expandMacro(

                  )

                  in line

              ):

          else:

              cmt = ""

              if not b_dir:

              if not b_test:

              if not b_rm:

              if not b_install:

              self.set_passed(self.FAIL, cmt)

                  self.set_passed(self.PASS)

          else:

              self.url = (

              )

              self.text = (

              )

              if bad_pkgs:

                  self.set_passed(

              "/packaging-guidelines/#_devel_packages"

          )

          self.text = (

          )

          self.automatic = True

          self.type = "MUST"

                  break

          else:

              self.set_passed(

              )

      def __init__(self, base):

          CCppCheckBase.__init__(self, base)

          self.url = (

          )

          self.text = (

              "If your application is a C or C++ application you must "

          br = self.spec.build_requires

          if not "gcc" in br and not "gcc-c++" in br and not "clang" in br:

              self.set_passed(

              )

              return

          self.set_passed(self.PASS)

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.automatic = True

          self.type = "MUST"

              "https://docs.fedoraproject.org/en-US"

              "/packaging-guidelines/#_compiler_flags"

          )

          self.automatic = True

          self.type = "MUST"

          self.needs.append("generic-large-data")  # Ensure unpacked rpms

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.url = (

          )

          self.text = "Changelog in prescribed format."

          self.automatic = False

              "/packaging-guidelines/what-can-be-packaged"

              "/#_impermissible_content"

          )

          self.automatic = False

          self.type = "MUST"

              "https://docs.fedoraproject.org/en-US"

              "/packaging-guidelines/#_configuration_files"

          )

          self.automatic = True

          self.type = "MUST"

              "https://docs.fedoraproject.org/en-US"

              "/packaging-guidelines/#_source_rpm_buildtime_macros"

          )

          self.automatic = True

          self.type = "MUST"

              "https://docs.fedoraproject.org/en-US"

              "/packaging-guidelines/#_desktop_files"

          )

          self.automatic = True

          self.type = "MUST"

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.text = "Dist tag is present."

          self.automatic = True

          self.type = "MUST"

              "https://docs.fedoraproject.org/en-US"

              "/packaging-guidelines/#_documentation"

          )

          self.automatic = False

          self.type = "MUST"

              "/packaging-guidelines/LicensingGuidelines/"

              "#_valid_license_short_names"

          )

          self.automatic = True

          self.type = "MUST"

              "/#subpackage-licensing"

          )

          self.text = (

          )

          self.automatic = False

          self.type = "MUST"

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.text = (

              "Package consistently uses macros"

              " (instead of hard-coded directory names)."

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.text = "Package uses either  %{buildroot} or $RPM_BUILD_ROOT"

          self.automatic = True

          self.type = "MUST"

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.text = "Package is named using only allowed ASCII characters."

          self.automatic = True

          self.type = "MUST"

      def run_on_applicable(self):

          allowed_chars = (

          )

          output = ""

          passed = True

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.automatic = False

          self.type = "MUST"

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.url = (

          )

          self.text = "Package does not generate any conflict."

          self.automatic = True

      def run(self):

          text = None

          if self.spec.expand_tag("Conflicts"):

          self.set_passed(self.PENDING, text)

              "https://docs.fedoraproject.org/en-US"

              "/packaging-guidelines/#_file_and_directory_ownership"

          )

          self.automatic = True

          self.type = "MUST"

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.url = (

          )

          self.text = (

              "Sources used to build the package match the"

              self.log.debug("No testable sources")

              self.set_passed(

                  self.PENDING,

              )

              return

          msg = "Check did not complete"

              "https://docs.fedoraproject.org/en-US"

              "/packaging-guidelines/#_debuginfo_packages"

          )

          self.automatic = False

          self.type = "MUST"

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.text = (

              "gtk-update-icon-cache is invoked in %postun"

              " and %posttrans if package contains icons."

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.text = (

              "update-desktop-database is invoked in %post and"

              " %postun if package contains desktop file(s)"

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.text = "gtk-query-immodules is invoked when required"

          self.automatic = True

                  "Packaging:Scriptlets&oldid=494555#GTK.2B_modules"

              )

              self.text = (

              )

              self.set_passed(self.FAIL if failed else self.NA, text)

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.text = (

              "glib-compile-schemas is run in %postun and"

              " %posttrans if package has *.gschema.xml files. "

      def __init__(self, base):

          GenericCheckBase.__init__(self, base)

          self.text = (

              "gdk-pixbuf-query-loaders is invoked in %post and"

              " %postun to update gdk-pixbuf"

              provides = deps.list_provides(pkg)

              if any("deprecated()" in p for p in provides):

                  self.set_passed(

                  )

                  return

                  bad_ones = list(set(bad_ones))

                  self.set_passed(self.FAIL, "--no-build: package(s) not installed")

                  self.log.info(

                      ", ".join(bad_ones),

                  )

              return

      def __init__(self, base):

          BuildCheckBase.__init__(self, base)

          self.url = (

          )

          self.text = "Rpmlint is run on all installed packages."

          self.automatic = True

      def __init__(self, base):

          BuildCheckBase.__init__(self, base)

          self.url = (

          )

          self.text = "Rpmlint is run on debuginfo package(s)."

          self.automatic = True

      def __init__(self, base):

          GenericShouldCheckBase.__init__(self, base)

          self.text = "Reviewer should test that the package builds in mock."

          self.automatic = True

          self.type = "SHOULD"

              "/packaging-guidelines/#_file_and_directory_dependencies"

          )

          self.text = (

          )

          self.automatic = True

          self.type = "SHOULD"

      def __init__(self, base):

          GenericShouldCheckBase.__init__(self, base)

          self.url = "https://docs.fedoraproject.org/en-US/packaging-guidelines/"

          self.automatic = False

          self.type = "SHOULD"

              "https://docs.fedoraproject.org/en-US"

              "/packaging-guidelines/#_requiring_base_package"

          )

          self.automatic = True

          self.type = "SHOULD"

              "/packaging-guidelines/#_tags_and_sections"

          )

          self.text = (

          )

          self.automatic = True

          self.type = "SHOULD"

              "/packaging-guidelines/LicensingGuidelines/#_license_text"

          )

          self.text = (

          )

          self.automatic = False

          self.type = "SHOULD"

      def __init__(self, base):

          GenericShouldCheckBase.__init__(self, base)

          self.url = (

          )

          self.text = "Man pages included for all executables."

          self.automatic = False

      def __init__(self, base):

          GenericShouldCheckBase.__init__(self, base)

          self.url = (

          )

          self.text = "Scriptlets must be sane, if used."

          self.automatic = False

      def __init__(self, base):

          GenericShouldCheckBase.__init__(self, base)

          self.url = (

          )

          self.text = "%check is present and all tests pass."

          self.automatic = False

      def __init__(self, base):

          GenericShouldCheckBase.__init__(self, base)

          self.url = (

          )

          self.text = (

          )

          self.automatic = False

          self.type = "SHOULD"

              "https://docs.fedoraproject.org/en-US"

              "/packaging-guidelines/#_global_preferred_over_define"

          )

          self.automatic = True

          self.type = "SHOULD"

              "https://docs.fedoraproject.org/en-US/packaging-guidelines/Tmpfiles.d/"

          )

          self.text = (

          )

          self.automatic = True

          self.type = "SHOULD"

      def __init__(self, base):

          GenericShouldCheckBase.__init__(self, base)

          self.url = (

          )

          self.text = "Sources can be downloaded from URI in Source: tag"

          self.automatic = True

      def __init__(self, base):

          GenericShouldCheckBase.__init__(self, base)

          self.text = (

              "update-mime-database is invoked in %posttrans and"

              " %postun if package stores mime configuration"

      def __init__(self, checks):

          PerlCheckBase.__init__(self, checks)

          self.url = "https://docs.fedoraproject.org/en-US/packaging-guidelines/Perl/"

          self.automatic = True

      def run_on_applicable(self):

          for br in self.spec.build_requires:

              if br.startswith("perl-devel"):

                  self.set_passed(

                  )

                  return

          compat = rpm.expandMacro(perl_compat)

          rr = self.spec.get_requires()

          if regex.search("\n".join(br)) or regex.search("\n".join(rr)):

              return

          self.set_passed(self.PASS)

          if _has_extension(self):

              self.set_passed(

                  "noarch" not in arch,

              )

          else:

              self.set_passed("noarch" in arch)

      def __init__(self, base):

          RubyCheckBase.__init__(self, base)

          self.url = _gl_fmt_uri(

          )

          self.automatic = True

      def is_applicable(self):

      def __init__(self, base):

          SugarActivityCheckBase.__init__(self, base)

          self.url = _SUGAR_URL + "_runtime_dependencies"

          self.type = "MUST"

          self.automatic = False

          build_data = get_build_data(build_id)

          if build_data["status"] != "succeeded":

              sys.exit(1)

          required_chroot = "fedora-rawhide-" + platform.machine()

      if not os.access(os.getcwd(), os.R_OK | os.W_OK | os.X_OK):

          raise IOError(

          )

      session = koji.ClientSession(opts.huburl)

      for task_id in task_ids:

          return flags["DISTTAG"].value

      self.log.warning("No disttag found in prebuilt packages")

      self.log.info(

      )

      raise ReviewError(

          "No disttag in package and no DISTTAG flag."

              self.log.debug("_topdir: %s", str(self._topdir))

          except (CalledProcessError, OSError):

              self.log.info(

              )

              self._topdir = "/builddir/build"

          except:

              self.log.debug("Exception down the road...", exc_info=True)

              self.log.error(

              )

              rcode = 1

          self.log.debug("Report completed:  %.3f seconds", time.time() - started_at)

          default=None,

          dest="url",

          metavar="<url>",

      )

      modes.add_argument(

          "--copr-build",

          "--cache",

          action="store_true",

          dest="cache",

      )

      optional.add_argument(

          "-D",

          action="append",

          dest="flags",

          default=[],

      )

      optional.add_argument(

          "-L",

          action="store_true",

          dest="prebuilt",

          default=False,

      )

      optional.add_argument(

          "-s",

          "--single",

          metavar="<test>",

      )

      optional.add_argument(

          "-r",

          action="store_true",

          dest="rpm_spec",

          default=False,

      )

      optional.add_argument(

          "-v",

              _make_log_dir()

              logging.basicConfig(

                  level=logging.DEBUG,

                  datefmt="%m-%d %H:%M",

                  filename=SESSION_LOG,

                  filemode="w",

          )

          if not rv:

              self.log.debug(

                  self.filename,

              )

              shutil.copy(os.path.join(self._unpacked_src, self.filename), extract_dir)

          )

          self.assertEqual(

              self.bug.spec_url,

          )

          cd = os.path.abspath("./srpm")

          self.assertTrue(os.path.exists(source.filename))

          self.assertEqual(

              source.check_source_checksum(),

          )

          source.extract()

          self.assertTrue(