VFWCVTXUFV	X10, V3				// ERROR "expected vector register in vs2 position"
	VFWCVTXFV	X10, V3				// ERROR "expected vector register in vs2 position"
	VFWCVTRTZXUFV	X10, V3				// ERROR "expected vector register in vs2 position"
	VFWCVTRTZXFV	X10, V3				// ERROR "expected vector register in vs2 position"
	VFWCVTFXUV	X10, V3				// ERROR "expected vector register in vs2 position"
	VFWCVTFXV	X10, V3				// ERROR "expected vector register in vs2 position"

    void testAs_Enumeration_Success() throws PACDecodingException {
        // Test successful casting from enumeration
        Vector<ASN1Integer> vector = new Vector<>();
        ASN1Integer expected = new ASN1Integer(123);
        vector.add(expected);
        ASN1Integer result = ASN1Util.as(ASN1Integer.class, vector.elements());
        assertSame(expected, result);
    }

    @Test
    void testAs_Enumeration_Failure() {

	VWADDWX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
	VWSUBWV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
	VWSUBWX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
	VWCVTXXV	V2, V1, V3			// ERROR "invalid vector mask register"
	VWCVTUXXV	V2, V1, V3			// ERROR "invalid vector mask register"
	VZEXTVF2	V2, V3, V4			// ERROR "invalid vector mask register"

     */
    @Test
    void testConstructorUnknownField() throws IOException {
        ASN1EncodableVector vector = new ASN1EncodableVector();
        vector.add(new DERTaggedObject(99, new DERGeneralString("unknown")));
        DERSequence sequence = new DERSequence(vector);
        byte[] encoded = new DERTaggedObject(false, BERTags.APPLICATION, 1, sequence).getEncoded();

    std::vector<TF_Output> out;
    for (auto op : ops) {
      out.push_back({op, 0});
    }
    return out;
  }

  void Define(int num_opers, const std::vector<TF_Operation*>& opers,
              const std::vector<TF_Operation*>& inputs,
              const std::vector<TF_Operation*>& outputs,
              const std::vector<string>& output_names,
              bool expect_failure = false) {

    // Input tensors
    const std::vector<std::pair<string, Tensor>>& input_pairs,
    // Output tensors
    const std::vector<string>& output_tensor_names, TF_Tensor** c_outputs,
    // Target nodes
    const std::vector<string>& target_oper_names, TF_Buffer* run_metadata,
    TF_Status* status) {
  const int noutputs = output_tensor_names.size();
  std::vector<Tensor> outputs(noutputs);
  Status result;

  if (!status->status.ok()) return;

  // Initialize a input_tensor vector with `nullptr` values.
  std::vector<const Tensor*> input_tensors_vector(num_inputs, nullptr);
  // A vector to keep track of newly created `tf::Tensor` objects.
  std::vector<Tensor> all_input_tensors;
  // Update the vector with information from `input_tensors` if provided.
  if (input_tensors != nullptr) {

	// 31.11.15: Vector Integer Merge Instructions
	VMERGEVVM	V1, V2, V0, V3			// d781205c
	VMERGEVXM	X10, V2, V0, V3			// d741255c
	VMERGEVIM	$15, V2, V0, V3			// d7b1275c

	// 31.11.16: Vector Integer Move Instructions
	VMVVV		V2, V3				// d701015e
	VMVVX		X10, V3				// d741055e
	VMVVI		$15, V3				// d7b1075e

	// 31.12.1: Vector Single-Width Saturating Add and Subtract

        .createTestSuite();
  }

  // We are testing Vector / testing our tests on Vector.
  @SuppressWarnings("JdkObsolete")
  private Test testsForVector() {
    return ListTestSuiteBuilder.using(
            new TestStringListGenerator() {
              @Override
              protected List<String> create(String[] elements) {
                return new Vector<>(MinimalCollection.of(elements));
              }
            })

        .createTestSuite();
  }

  // We are testing Vector / testing our tests on Vector.
  @SuppressWarnings("JdkObsolete")
  private Test testsForVector() {
    return ListTestSuiteBuilder.using(
            new TestStringListGenerator() {
              @Override
              protected List<String> create(String[] elements) {
                return new Vector<>(MinimalCollection.of(elements));
              }
            })