text: # This file is dual licensed under the terms of the Apache License, Version
  # 2.0, and the BSD License. See the LICENSE file in the root of this repository
  # for complete details.
  
  from __future__ import absolute_import, division, print_function
  
  import binascii
  import collections
  import json
  import os
  import re
  from contextlib import contextmanager
  
  import pytest
  
  import six
  
  from cryptography.exceptions import UnsupportedAlgorithm
  
  import cryptography_vectors
  
  
  HashVector = collections.namedtuple("HashVector", ["message", "digest"])
  KeyedHashVector = collections.namedtuple(
      "KeyedHashVector", ["message", "digest", "key"]
  )
  
  
  def check_backend_support(backend, item):
      for mark in item.node.iter_markers("supported"):
          if not mark.kwargs["only_if"](backend):
              pytest.skip("{} ({})".format(
                  mark.kwargs["skip_message"], backend
              ))
  
  
  @contextmanager
  def raises_unsupported_algorithm(reason):
      with pytest.raises(UnsupportedAlgorithm) as exc_info:
          yield exc_info
  
      assert exc_info.value._reason is reason
  
  
  def load_vectors_from_file(filename, loader, mode="r"):
      with cryptography_vectors.open_vector_file(filename, mode) as vector_file:
          return loader(vector_file)
  
  
  def load_nist_vectors(vector_data):
      test_data = None
      data = []
  
      for line in vector_data:
          line = line.strip()
  
          # Blank lines, comments, and section headers are ignored
          if not line or line.startswith("#") or (line.startswith("[") and
                                                  line.endswith("]")):
              continue
  
          if line.strip() == "FAIL":
              test_data["fail"] = True
              continue
  
          # Build our data using a simple Key = Value format
          name, value = [c.strip() for c in line.split("=")]
  
          # Some tests (PBKDF2) contain \0, which should be interpreted as a
          # null character rather than literal.
          value = value.replace("\\0", "\0")
  
          # COUNT is a special token that indicates a new block of data
          if name.upper() == "COUNT":
              test_data = {}
              data.append(test_data)
              continue
          # For all other tokens we simply want the name, value stored in
          # the dictionary
          else:
              test_data[name.lower()] = value.encode("ascii")
  
      return data
  
  
  def load_cryptrec_vectors(vector_data):
      cryptrec_list = []
  
      for line in vector_data:
          line = line.strip()
  
          # Blank lines and comments are ignored
          if not line or line.startswith("#"):
              continue
  
          if line.startswith("K"):
              key = line.split(" : ")[1].replace(" ", "").encode("ascii")
          elif line.startswith("P"):
              pt = line.split(" : ")[1].replace(" ", "").encode("ascii")
          elif line.startswith("C"):
              ct = line.split(" : ")[1].replace(" ", "").encode("ascii")
              # after a C is found the K+P+C tuple is complete
              # there are many P+C pairs for each K
              cryptrec_list.append({
                  "key": key,
                  "plaintext": pt,
                  "ciphertext": ct
              })
          else:
              raise ValueError("Invalid line in file '{}'".format(line))
      return cryptrec_list
  
  
  def load_hash_vectors(vector_data):
      vectors = []
      key = None
      msg = None
      md = None
  
      for line in vector_data:
          line = line.strip()
  
          if not line or line.startswith("#") or line.startswith("["):
              continue
  
          if line.startswith("Len"):
              length = int(line.split(" = ")[1])
          elif line.startswith("Key"):
              # HMAC vectors contain a key attribute. Hash vectors do not.
              key = line.split(" = ")[1].encode("ascii")
          elif line.startswith("Msg"):
              # In the NIST vectors they have chosen to represent an empty
              # string as hex 00, which is of course not actually an empty
              # string. So we parse the provided length and catch this edge case.
              msg = line.split(" = ")[1].encode("ascii") if length > 0 else b""
          elif line.startswith("MD") or line.startswith("Output"):
              md = line.split(" = ")[1]
              # after MD is found the Msg+MD (+ potential key) tuple is complete
              if key is not None:
                  vectors.append(KeyedHashVector(msg, md, key))
                  key = None
                  msg = None
                  md = None
              else:
                  vectors.append(HashVector(msg, md))
                  msg = None
                  md = None
          else:
              raise ValueError("Unknown line in hash vector")
      return vectors
  
  
  def load_pkcs1_vectors(vector_data):
      """
      Loads data out of RSA PKCS #1 vector files.
      """
      private_key_vector = None
      public_key_vector = None
      attr = None
      key = None
      example_vector = None
      examples = []
      vectors = []
      for line in vector_data:
          if (
              line.startswith("# PSS Example") or
              line.startswith("# OAEP Example") or
              line.startswith("# PKCS#1 v1.5")
          ):
              if example_vector:
                  for key, value in six.iteritems(example_vector):
                      hex_str = "".join(value).replace(" ", "").encode("ascii")
                      example_vector[key] = hex_str
                  examples.append(example_vector)
  
              attr = None
              example_vector = collections.defaultdict(list)
  
          if line.startswith("# Message"):
              attr = "message"
              continue
          elif line.startswith("# Salt"):
              attr = "salt"
              continue
          elif line.startswith("# Seed"):
              attr = "seed"
              continue
          elif line.startswith("# Signature"):
              attr = "signature"
              continue
          elif line.startswith("# Encryption"):
              attr = "encryption"
              continue
          elif (
              example_vector and
              line.startswith("# =============================================")
          ):
              for key, value in six.iteritems(example_vector):
                  hex_str = "".join(value).replace(" ", "").encode("ascii")
                  example_vector[key] = hex_str
              examples.append(example_vector)
              example_vector = None
              attr = None
          elif example_vector and line.startswith("#"):
              continue
          else:
              if attr is not None and example_vector is not None:
                  example_vector[attr].append(line.strip())
                  continue
  
          if (
              line.startswith("# Example") or
              line.startswith("# =============================================")
          ):
              if key:
                  assert private_key_vector
                  assert public_key_vector
  
                  for key, value in six.iteritems(public_key_vector):
                      hex_str = "".join(value).replace(" ", "")
                      public_key_vector[key] = int(hex_str, 16)
  
                  for key, value in six.iteritems(private_key_vector):
                      hex_str = "".join(value).replace(" ", "")
                      private_key_vector[key] = int(hex_str, 16)
  
                  private_key_vector["examples"] = examples
                  examples = []
  
                  assert (
                      private_key_vector['public_exponent'] ==
                      public_key_vector['public_exponent']
                  )
  
                  assert (
                      private_key_vector['modulus'] ==
                      public_key_vector['modulus']
                  )
  
                  vectors.append(
                      (private_key_vector, public_key_vector)
                  )
  
              public_key_vector = collections.defaultdict(list)
              private_key_vector = collections.defaultdict(list)
              key = None
              attr = None
  
          if private_key_vector is None or public_key_vector is None:
              # Random garbage to defeat CPython's peephole optimizer so that
              # coverage records correctly: https://bugs.python.org/issue2506
              1 + 1
              continue
  
          if line.startswith("# Private key"):
              key = private_key_vector
          elif line.startswith("# Public key"):
              key = public_key_vector
          elif line.startswith("# Modulus:"):
              attr = "modulus"
          elif line.startswith("# Public exponent:"):
              attr = "public_exponent"
          elif line.startswith("# Exponent:"):
              if key is public_key_vector:
                  attr = "public_exponent"
              else:
                  assert key is private_key_vector
                  attr = "private_exponent"
          elif line.startswith("# Prime 1:"):
              attr = "p"
          elif line.startswith("# Prime 2:"):
              attr = "q"
          elif line.startswith("# Prime exponent 1:"):
              attr = "dmp1"
          elif line.startswith("# Prime exponent 2:"):
              attr = "dmq1"
          elif line.startswith("# Coefficient:"):
              attr = "iqmp"
          elif line.startswith("#"):
              attr = None
          else:
              if key is not None and attr is not None:
                  key[attr].append(line.strip())
      return vectors
  
  
  def load_rsa_nist_vectors(vector_data):
      test_data = None
      p = None
      salt_length = None
      data = []
  
      for line in vector_data:
          line = line.strip()
  
          # Blank lines and section headers are ignored
          if not line or line.startswith("["):
              continue
  
          if line.startswith("# Salt len:"):
              salt_length = int(line.split(":")[1].strip())
              continue
          elif line.startswith("#"):
              continue
  
          # Build our data using a simple Key = Value format
          name, value = [c.strip() for c in line.split("=")]
  
          if name == "n":
              n = int(value, 16)
          elif name == "e" and p is None:
              e = int(value, 16)
          elif name == "p":
              p = int(value, 16)
          elif name == "q":
              q = int(value, 16)
          elif name == "SHAAlg":
              if p is None:
                  test_data = {
                      "modulus": n,
                      "public_exponent": e,
                      "salt_length": salt_length,
                      "algorithm": value,
                      "fail": False
                  }
              else:
                  test_data = {
                      "modulus": n,
                      "p": p,
                      "q": q,
                      "algorithm": value
                  }
                  if salt_length is not None:
                      test_data["salt_length"] = salt_length
              data.append(test_data)
          elif name == "e" and p is not None:
              test_data["public_exponent"] = int(value, 16)
          elif name == "d":
              test_data["private_exponent"] = int(value, 16)
          elif name == "Result":
              test_data["fail"] = value.startswith("F")
          # For all other tokens we simply want the name, value stored in
          # the dictionary
          else:
              test_data[name.lower()] = value.encode("ascii")
  
      return data
  
  
  def load_fips_dsa_key_pair_vectors(vector_data):
      """
      Loads data out of the FIPS DSA KeyPair vector files.
      """
      vectors = []
      for line in vector_data:
          line = line.strip()
  
          if not line or line.startswith("#") or line.startswith("[mod"):
              continue
  
          if line.startswith("P"):
              vectors.append({'p': int(line.split("=")[1], 16)})
          elif line.startswith("Q"):
              vectors[-1]['q'] = int(line.split("=")[1], 16)
          elif line.startswith("G"):
              vectors[-1]['g'] = int(line.split("=")[1], 16)
          elif line.startswith("X") and 'x' not in vectors[-1]:
              vectors[-1]['x'] = int(line.split("=")[1], 16)
          elif line.startswith("X") and 'x' in vectors[-1]:
              vectors.append({'p': vectors[-1]['p'],
                              'q': vectors[-1]['q'],
                              'g': vectors[-1]['g'],
                              'x': int(line.split("=")[1], 16)
                              })
          elif line.startswith("Y"):
              vectors[-1]['y'] = int(line.split("=")[1], 16)
  
      return vectors
  
  
  def load_fips_dsa_sig_vectors(vector_data):
      """
      Loads data out of the FIPS DSA SigVer vector files.
      """
      vectors = []
      sha_regex = re.compile(
          r"\[mod = L=...., N=..., SHA-(?P<sha>1|224|256|384|512)\]"
      )
  
      for line in vector_data:
          line = line.strip()
  
          if not line or line.startswith("#"):
              continue
  
          sha_match = sha_regex.match(line)
          if sha_match:
              digest_algorithm = "SHA-{}".format(sha_match.group("sha"))
  
          if line.startswith("[mod"):
              continue
  
          name, value = [c.strip() for c in line.split("=")]
  
          if name == "P":
              vectors.append({'p': int(value, 16),
                              'digest_algorithm': digest_algorithm})
          elif name == "Q":
              vectors[-1]['q'] = int(value, 16)
          elif name == "G":
              vectors[-1]['g'] = int(value, 16)
          elif name == "Msg" and 'msg' not in vectors[-1]:
              hexmsg = value.strip().encode("ascii")
              vectors[-1]['msg'] = binascii.unhexlify(hexmsg)
          elif name == "Msg" and 'msg' in vectors[-1]:
              hexmsg = value.strip().encode("ascii")
              vectors.append({'p': vectors[-1]['p'],
                              'q': vectors[-1]['q'],
                              'g': vectors[-1]['g'],
                              'digest_algorithm':
                              vectors[-1]['digest_algorithm'],
                              'msg': binascii.unhexlify(hexmsg)})
          elif name == "X":
              vectors[-1]['x'] = int(value, 16)
          elif name == "Y":
              vectors[-1]['y'] = int(value, 16)
          elif name == "R":
              vectors[-1]['r'] = int(value, 16)
          elif name == "S":
              vectors[-1]['s'] = int(value, 16)
          elif name == "Result":
              vectors[-1]['result'] = value.split("(")[0].strip()
  
      return vectors
  
  
  # https://tools.ietf.org/html/rfc4492#appendix-A
  _ECDSA_CURVE_NAMES = {
      "P-192": "secp192r1",
      "P-224": "secp224r1",
      "P-256": "secp256r1",
      "P-384": "secp384r1",
      "P-521": "secp521r1",
  
      "K-163": "sect163k1",
      "K-233": "sect233k1",
      "K-256": "secp256k1",
      "K-283": "sect283k1",
      "K-409": "sect409k1",
      "K-571": "sect571k1",
  
      "B-163": "sect163r2",
      "B-233": "sect233r1",
      "B-283": "sect283r1",
      "B-409": "sect409r1",
      "B-571": "sect571r1",
  }
  
  
  def load_fips_ecdsa_key_pair_vectors(vector_data):
      """
      Loads data out of the FIPS ECDSA KeyPair vector files.
      """
      vectors = []
      key_data = None
      for line in vector_data:
          line = line.strip()
  
          if not line or line.startswith("#"):
              continue
  
          if line[1:-1] in _ECDSA_CURVE_NAMES:
              curve_name = _ECDSA_CURVE_NAMES[line[1:-1]]
  
          elif line.startswith("d = "):
              if key_data is not None:
                  vectors.append(key_data)
  
              key_data = {
                  "curve": curve_name,
                  "d": int(line.split("=")[1], 16)
              }
  
          elif key_data is not None:
              if line.startswith("Qx = "):
                  key_data["x"] = int(line.split("=")[1], 16)
              elif line.startswith("Qy = "):
                  key_data["y"] = int(line.split("=")[1], 16)
  
      assert key_data is not None
      vectors.append(key_data)
  
      return vectors
  
  
  def load_fips_ecdsa_signing_vectors(vector_data):
      """
      Loads data out of the FIPS ECDSA SigGen vector files.
      """
      vectors = []
  
      curve_rx = re.compile(
          r"\[(?P<curve>[PKB]-[0-9]{3}),SHA-(?P<sha>1|224|256|384|512)\]"
      )
  
      data = None
      for line in vector_data:
          line = line.strip()
  
          curve_match = curve_rx.match(line)
          if curve_match:
              curve_name = _ECDSA_CURVE_NAMES[curve_match.group("curve")]
              digest_name = "SHA-{}".format(curve_match.group("sha"))
  
          elif line.startswith("Msg = "):
              if data is not None:
                  vectors.append(data)
  
              hexmsg = line.split("=")[1].strip().encode("ascii")
  
              data = {
                  "curve": curve_name,
                  "digest_algorithm": digest_name,
                  "message": binascii.unhexlify(hexmsg)
              }
  
          elif data is not None:
              if line.startswith("Qx = "):
                  data["x"] = int(line.split("=")[1], 16)
              elif line.startswith("Qy = "):
                  data["y"] = int(line.split("=")[1], 16)
              elif line.startswith("R = "):
                  data["r"] = int(line.split("=")[1], 16)
              elif line.startswith("S = "):
                  data["s"] = int(line.split("=")[1], 16)
              elif line.startswith("d = "):
                  data["d"] = int(line.split("=")[1], 16)
              elif line.startswith("Result = "):
                  data["fail"] = line.split("=")[1].strip()[0] == "F"
  
      assert data is not None
      vectors.append(data)
      return vectors
  
  
  def load_kasvs_dh_vectors(vector_data):
      """
      Loads data out of the KASVS key exchange vector data
      """
  
      result_rx = re.compile(r"([FP]) \(([0-9]+) -")
  
      vectors = []
      data = {
          "fail_z": False,
          "fail_agree": False
      }
  
      for line in vector_data:
          line = line.strip()
  
          if not line or line.startswith("#"):
              continue
  
          if line.startswith("P = "):
              data["p"] = int(line.split("=")[1], 16)
          elif line.startswith("Q = "):
              data["q"] = int(line.split("=")[1], 16)
          elif line.startswith("G = "):
              data["g"] = int(line.split("=")[1], 16)
          elif line.startswith("Z = "):
              z_hex = line.split("=")[1].strip().encode("ascii")
              data["z"] = binascii.unhexlify(z_hex)
          elif line.startswith("XstatCAVS = "):
              data["x1"] = int(line.split("=")[1], 16)
          elif line.startswith("YstatCAVS = "):
              data["y1"] = int(line.split("=")[1], 16)
          elif line.startswith("XstatIUT = "):
              data["x2"] = int(line.split("=")[1], 16)
          elif line.startswith("YstatIUT = "):
              data["y2"] = int(line.split("=")[1], 16)
          elif line.startswith("Result = "):
              result_str = line.split("=")[1].strip()
              match = result_rx.match(result_str)
  
              if match.group(1) == "F":
                  if int(match.group(2)) in (5, 10):
                      data["fail_z"] = True
                  else:
                      data["fail_agree"] = True
  
              vectors.append(data)
  
              data = {
                  "p": data["p"],
                  "q": data["q"],
                  "g": data["g"],
                  "fail_z": False,
                  "fail_agree": False
              }
  
      return vectors
  
  
  def load_kasvs_ecdh_vectors(vector_data):
      """
      Loads data out of the KASVS key exchange vector data
      """
  
      curve_name_map = {
          "P-192": "secp192r1",
          "P-224": "secp224r1",
          "P-256": "secp256r1",
          "P-384": "secp384r1",
          "P-521": "secp521r1",
      }
  
      result_rx = re.compile(r"([FP]) \(([0-9]+) -")
  
      tags = []
      sets = {}
      vectors = []
  
      # find info in header
      for line in vector_data:
          line = line.strip()
  
          if line.startswith("#"):
              parm = line.split("Parameter set(s) supported:")
              if len(parm) == 2:
                  names = parm[1].strip().split()
                  for n in names:
                      tags.append("[%s]" % n)
                  break
  
      # Sets Metadata
      tag = None
      curve = None
      for line in vector_data:
          line = line.strip()
  
          if not line or line.startswith("#"):
              continue
  
          if line in tags:
              tag = line
              curve = None
          elif line.startswith("[Curve selected:"):
              curve = curve_name_map[line.split(':')[1].strip()[:-1]]
  
          if tag is not None and curve is not None:
              sets[tag.strip("[]")] = curve
              tag = None
          if len(tags) == len(sets):
              break
  
      # Data
      data = {
          "CAVS": {},
          "IUT": {},
      }
      tag = None
      for line in vector_data:
          line = line.strip()
  
          if not line or line.startswith("#"):
              continue
  
          if line.startswith("["):
              tag = line.split()[0][1:]
          elif line.startswith("COUNT = "):
              data["COUNT"] = int(line.split("=")[1])
          elif line.startswith("dsCAVS = "):
              data["CAVS"]["d"] = int(line.split("=")[1], 16)
          elif line.startswith("QsCAVSx = "):
              data["CAVS"]["x"] = int(line.split("=")[1], 16)
          elif line.startswith("QsCAVSy = "):
              data["CAVS"]["y"] = int(line.split("=")[1], 16)
          elif line.startswith("dsIUT = "):
              data["IUT"]["d"] = int(line.split("=")[1], 16)
          elif line.startswith("QsIUTx = "):
              data["IUT"]["x"] = int(line.split("=")[1], 16)
          elif line.startswith("QsIUTy = "):
              data["IUT"]["y"] = int(line.split("=")[1], 16)
          elif line.startswith("OI = "):
              data["OI"] = int(line.split("=")[1], 16)
          elif line.startswith("Z = "):
              data["Z"] = int(line.split("=")[1], 16)
          elif line.startswith("DKM = "):
              data["DKM"] = int(line.split("=")[1], 16)
          elif line.startswith("Result = "):
              result_str = line.split("=")[1].strip()
              match = result_rx.match(result_str)
  
              if match.group(1) == "F":
                  data["fail"] = True
              else:
                  data["fail"] = False
              data["errno"] = int(match.group(2))
  
              data["curve"] = sets[tag]
  
              vectors.append(data)
  
              data = {
                  "CAVS": {},
                  "IUT": {},
              }
  
      return vectors
  
  
  def load_x963_vectors(vector_data):
      """
      Loads data out of the X9.63 vector data
      """
  
      vectors = []
  
      # Sets Metadata
      hashname = None
      vector = {}
      for line in vector_data:
          line = line.strip()
  
          if line.startswith("[SHA"):
              hashname = line[1:-1]
              shared_secret_len = 0
              shared_info_len = 0
              key_data_len = 0
          elif line.startswith("[shared secret length"):
              shared_secret_len = int(line[1:-1].split("=")[1].strip())
          elif line.startswith("[SharedInfo length"):
              shared_info_len = int(line[1:-1].split("=")[1].strip())
          elif line.startswith("[key data length"):
              key_data_len = int(line[1:-1].split("=")[1].strip())
          elif line.startswith("COUNT"):
              count = int(line.split("=")[1].strip())
              vector["hash"] = hashname
              vector["count"] = count
              vector["shared_secret_length"] = shared_secret_len
              vector["sharedinfo_length"] = shared_info_len
              vector["key_data_length"] = key_data_len
          elif line.startswith("Z"):
              vector["Z"] = line.split("=")[1].strip()
              assert ((shared_secret_len + 7) // 8) * 2 == len(vector["Z"])
          elif line.startswith("SharedInfo"):
              if shared_info_len != 0:
                  vector["sharedinfo"] = line.split("=")[1].strip()
                  silen = len(vector["sharedinfo"])
                  assert ((shared_info_len + 7) // 8) * 2 == silen
          elif line.startswith("key_data"):
              vector["key_data"] = line.split("=")[1].strip()
              assert ((key_data_len + 7) // 8) * 2 == len(vector["key_data"])
              vectors.append(vector)
              vector = {}
  
      return vectors
  
  
  def load_nist_kbkdf_vectors(vector_data):
      """
      Load NIST SP 800-108 KDF Vectors
      """
      vectors = []
      test_data = None
      tag = {}
  
      for line in vector_data:
          line = line.strip()
  
          if not line or line.startswith("#"):
              continue
  
          if line.startswith("[") and line.endswith("]"):
              tag_data = line[1:-1]
              name, value = [c.strip() for c in tag_data.split("=")]
              if value.endswith('_BITS'):
                  value = int(value.split('_')[0])
                  tag.update({name.lower(): value})
                  continue
  
              tag.update({name.lower(): value.lower()})
          elif line.startswith("COUNT="):
              test_data = {}
              test_data.update(tag)
              vectors.append(test_data)
          elif line.startswith("L"):
              name, value = [c.strip() for c in line.split("=")]
              test_data[name.lower()] = int(value)
          else:
              name, value = [c.strip() for c in line.split("=")]
              test_data[name.lower()] = value.encode("ascii")
  
      return vectors
  
  
  def load_ed25519_vectors(vector_data):
      data = []
      for line in vector_data:
          secret_key, public_key, message, signature, _ = line.split(':')
          # In the vectors the first element is secret key + public key
          secret_key = secret_key[0:64]
          # In the vectors the signature section is signature + message
          signature = signature[0:128]
          data.append({
              "secret_key": secret_key,
              "public_key": public_key,
              "message": message,
              "signature": signature
          })
      return data
  
  
  def load_nist_ccm_vectors(vector_data):
      test_data = None
      section_data = None
      global_data = {}
      new_section = False
      data = []
  
      for line in vector_data:
          line = line.strip()
  
          # Blank lines and comments should be ignored
          if not line or line.startswith("#"):
              continue
  
          # Some of the CCM vectors have global values for this. They are always
          # at the top before the first section header (see: VADT, VNT, VPT)
          if line.startswith(("Alen", "Plen", "Nlen", "Tlen")):
              name, value = [c.strip() for c in line.split("=")]
              global_data[name.lower()] = int(value)
              continue
  
          # section headers contain length data we might care about
          if line.startswith("["):
              new_section = True
              section_data = {}
              section = line[1:-1]
              items = [c.strip() for c in section.split(",")]
              for item in items:
                  name, value = [c.strip() for c in item.split("=")]
                  section_data[name.lower()] = int(value)
              continue
  
          name, value = [c.strip() for c in line.split("=")]
  
          if name.lower() in ("key", "nonce") and new_section:
              section_data[name.lower()] = value.encode("ascii")
              continue
  
          new_section = False
  
          # Payload is sometimes special because these vectors are absurd. Each
          # example may or may not have a payload. If it does not then the
          # previous example's payload should be used. We accomplish this by
          # writing it into the section_data. Because we update each example
          # with the section data it will be overwritten if a new payload value
          # is present. NIST should be ashamed of their vector creation.
          if name.lower() == "payload":
              section_data[name.lower()] = value.encode("ascii")
  
          # Result is a special token telling us if the test should pass/fail.
          # This is only present in the DVPT CCM tests
          if name.lower() == "result":
              if value.lower() == "pass":
                  test_data["fail"] = False
              else:
                  test_data["fail"] = True
              continue
  
          # COUNT is a special token that indicates a new block of data
          if name.lower() == "count":
              test_data = {}
              test_data.update(global_data)
              test_data.update(section_data)
              data.append(test_data)
              continue
          # For all other tokens we simply want the name, value stored in
          # the dictionary
          else:
              test_data[name.lower()] = value.encode("ascii")
  
      return data
  
  
  class WycheproofTest(object):
      def __init__(self, testfiledata, testgroup, testcase):
          self.testfiledata = testfiledata
          self.testgroup = testgroup
          self.testcase = testcase
  
      def __repr__(self):
          return "<WycheproofTest({!r}, {!r}, {!r}, tcId={})>".format(
              self.testfiledata,
              self.testgroup,
              self.testcase,
              self.testcase["tcId"],
          )
  
      @property
      def valid(self):
          return self.testcase["result"] == "valid"
  
      @property
      def acceptable(self):
          return self.testcase["result"] == "acceptable"
  
      @property
      def invalid(self):
          return self.testcase["result"] == "invalid"
  
      def has_flag(self, flag):
          return flag in self.testcase["flags"]
  
  
  def skip_if_wycheproof_none(wycheproof):
      # This is factored into its own function so we can easily test both
      # branches
      if wycheproof is None:
          pytest.skip("--wycheproof-root not provided")
  
  
  def load_wycheproof_tests(wycheproof, test_file):
      path = os.path.join(wycheproof, "testvectors", test_file)
      with open(path) as f:
          data = json.load(f)
          for group in data.pop("testGroups"):
              cases = group.pop("tests")
              for c in cases:
                  yield WycheproofTest(data, group, c)
  