def run_on_applicable(self):

          """ Run the check """

          up_version = self.get_upstream_r_package_version()

          if up_version is None:

              self.set_passed(

                  "The package does not come from one of the standard sources",

              )

              return

          self.set_passed(

              up_version == cur_version,

          if self.is_user_enabled():

              return self.user_enabled_value()

          archs = self.checks.spec.expand_tag("BuildArchs")

              return False

          if self.checks.buildsrc.is_available:

              src = self.checks.buildsrc

      def run(self):

          archs = self.checks.spec.expand_tag("BuildArchs")

              self.set_passed(self.NA)

              return

          self.set_passed(self.PENDING)

      def run(self):

          bad_tags = []

          for pkg_name in self.spec.packages:

                  bad_tags.append(pkg_name + " (summary)")

                  bad_tags.append(pkg_name + " (description)")

          if bad_tags:

              self.set_passed(self.PENDING, "Macros in: " + ", ".join(bad_tags))

              return "UNKNOWN" not in _license and "GENERATED" not in _license

          files_by_license = {}

              try:

                  file_, license_ = line.split(":")

              except ValueError:

          self.type = "MUST"

      def is_applicable(self):

          return "and" in license_ or "or" in license_

          if len(self.spec.packages) == 1:

              self.set_passed(self.NA)

              return

              isa = ""

          else:

              isa = Mock.get_macro("%_isa", self.spec, self.flags)

          for tag in ("Packager", "Vendor", "PreReq", "Copyright"):

              if not self.spec.find_re(r"^\s*" + tag + r"\s*:"):

                  continue

              if value:

                  passed = False

                  output += "Found : {}: {}\n".format(tag, value)

          build_ok = self.checks.checkdict["CheckBuild"].is_passed

          arch = self.spec.expand_tag("BuildArch")

          one_arch = self.spec.expand_tag("ExclusiveArch")

          if build_ok and (one_arch or noarch):

              self.set_passed(self.PASS)

          self.automatic = True

      def run_on_applicable(self):

          if _has_extension(self):

              self.set_passed(

                  "noarch" not in arch,

      """ Substitute a spec tag into env. """

      value = spec.expand_tag(tag.upper())

      if value:

      else:

          env = env.replace("@" + tag + "@", '""')

      return env

      def retrieve_description(self):

          """ Retrieve the description tag from a spec file. """

          self.log.debug("Description: %s", description)

          return description

      def retrieve_name(self):

          """ Retrieve the name tag from a spec file. """

          self.log.debug("Name: %s", name)

          return name

      def retrieve_summary(self):

          """ Retrieve the summary tag from a spec file. """

          self.log.debug("Summary: %s", summary)

          return summary

  import rpm

  from .mock import Mock

  from .settings import Settings

          eq = rpm.RPMSENSE_EQUAL

          for ix in range(0, len(names) - 1):

              if not versions[ix]:

                  continue

              if sense[ix] and eq:

                  s += "= "

              elif sense[ix] and lt:

              else:

                  s += "What? : " + bin(sense[ix])

                  self.log.warning("Bad RPMSENSE: %s", bin(sense[ix]))

              dp.append(s)

          return dp

          self.filename = Mock.get_package_rpm_path(self)

          fd = os.open(self.filename, os.O_RDONLY)

          os.close(fd)

          self._inited = True

      def header_to_str(self, tag):

          """ Convert header in a string, to cope with API changes in F18"""

          if isinstance(self.header[tag], (dict, list)):

          elif self.header[tag]:

          else:

              return None

      def filelist(self):

          """ List of files in this rpm (expanded). """

          self.init()

      @property

      def requires(self):

          """ List of requires, also auto-generated for rpm. """

          self.init()

      @property

      def provides(self):

          """ List of provides, also auto-generated for rpm. """

          self.init()

      @property

      def format_requires(self):

  import rpm

  from .review_error import ReviewError, SpecParseReviewError

  from .settings import Settings

  from .mock import Mock

          def parse_spec():

              """ Let rpm parse the spec and build spec.spec (sic!). """

              try:

              except Exception as ex:

                  raise SpecParseReviewError("Can't parse specfile: " + ex.__str__())

          sys.stdout = stdout

          self._packages = None

          self.name_vers_rel = [

              "*",

          ]

          update_macros()

          parse_spec()

      name = property(lambda self: self.name_vers_rel[0])

      version = property(lambda self: self.name_vers_rel[1])

                  )

                  return None

          pkgs = [p for p in pkgs if not self.get_files(p) is None]

          return [p for p in pkgs if check_pkg_path(p)]

          if not pkg_name:

              return self.spec.packages[0]

          for p in self.spec.packages:

                  return p

          raise KeyError(pkg_name + ": no such package")

      @property

      def build_requires(self):

          """ Return the list of build requirements. """

      def get_requires(self, pkg_name=None):

          """ Return list of requirements i. e., Requires: """

          package = self._get_pkg_by_name(pkg_name)

      def get_package_nvr(self, pkg_name=None):

          """ Return object with name, version, release for a package. """

          package = self._get_pkg_by_name(pkg_name)

          nvr = NVR()

          return nvr

      def get_files(self, pkg_name=None):

              return self._parse_files(pkg_name)

          if files is None:

              return None

      def get_section(self, section, raw=False):

          """

  def _proper_dist_os():

      """ Return true if we can create a dist on this OS. """

      if "el6" in uname_r:

          return False

      return True

          self.assertEqual(spec.version, "1.0")

          dist = Mock.get_macro("%dist", None, {})

          self.assertEqual(spec.release, "1" + dist)

          # Test rpm value not there

          # Test get sections

          expected = ["rm -rf $RPM_BUILD_ROOT"]

          self.assertEqual(spec.get_section("%clean"), expected)

      def test_version(self):

          """ test --version option. """

          cmd = srcpath.REVIEW_PATH + " --version"

          self.assertIn("fedora-review", output)

          self.assertIn(VERSION, output)