}

    /**
     * Test constructor with APPLICATION tag but non-sequence content.
     *
     * @throws IOException if an I/O error occurs
     */
    @Test
    void testConstructorWithNonSequenceContent() throws IOException {
        // Create APPLICATION tagged object with non-sequence content
        DERTaggedObject appTag = new DERTaggedObject(false, BERTags.APPLICATION | 14, new ASN1Integer(5));

   *
   * <p>See {@link com.google.common.net.PercentEscaper} for an example.
   *
   * @param csq a sequence of characters
   * @param start the index of the first character to be scanned
   * @param end the index immediately after the last character to be scanned
   * @throws IllegalArgumentException if the scanned sub-sequence of {@code csq} contains invalid
   *     surrogate pairs
   */

   * characters which constitute a machine-sensible address or routing information. Such a sequence
   * is referred to as the "heading." An STX character has the effect of terminating a heading.
   *
   * @since 8.0
   */
  public static final byte SOH = 1;

  /**
   * Start of Text: A communication control character which precedes a sequence of characters that

        return "REG-" + System.currentTimeMillis() + "-" + Integer.toHexString(System.identityHashCode(this));
    }

    /**
     * Gets the next sequence number for this registration.
     *
     * @return the next sequence number
     */
    public long getNextSequenceNumber() {
        return sequenceNumber.incrementAndGet();
    }

    /**

  /** Returns the element with the specified index. This method is called by {@link #next()}. */
  @ParametricNullness
  protected abstract E get(int index);

  /**
   * Constructs an iterator across a sequence of the given size whose initial position is 0. That
   * is, the first call to {@link #next()} will return the first element (or throw {@link
   * NoSuchElementException} if {@code size} is zero).
   *

        mockedStaticAuthData.when(() -> KerberosAuthData.parse(anyInt(), any(byte[].class), any(Map.class)))
                .thenReturn(Collections.singletonList(mockAuthData));

        // Construct a valid ASN.1 sequence for KerberosRelevantAuthData
        ASN1EncodableVector authVector = new ASN1EncodableVector();
        ASN1EncodableVector elementVector = new ASN1EncodableVector();

				m.close()
				return
			}
		}
	}
}

// checkSeq will check if sequence number is correct and increment it by 1.
func (m *muxServer) checkSeq(seq uint32) (ok bool) {
	if seq != m.RecvSeq {
		if debugPrint {
			fmt.Printf("expected sequence %d, got %d\n", m.RecvSeq, seq)
		}
		m.disconnect(fmt.Sprintf("receive sequence number mismatch. want %d, got %d", m.RecvSeq, seq), false)
		return false
	}
	m.RecvSeq++

   * {@code sequence} as a sequence of Unicode code units. The view does not support any
   * modification operations, but reflects any changes to the underlying character sequence.
   *
   * @param sequence the character sequence to view as a {@code List} of characters
   * @return an {@code List<Character>} view of the character sequence
   * @since 7.0
   */

        assertNotNull(digest);
        assertTrue(digest.toString().contains("MacSigningKey="));
    }

    @Test
    @DisplayName("Test constructor with MAC signing key, bypass flag and initial sequence")
    void testConstructorWithBypassAndInitialSequence() {
        int initialSequence = 100;
        SMB1SigningDigest digest = new SMB1SigningDigest(testMacSigningKey, true, initialSequence);
        assertNotNull(digest);

    return known_models


def get_flat_models_from_fields(
    fields: Sequence[ModelField], known_models: TypeModelSet
) -> TypeModelSet:
    for field in fields:
        get_flat_models_from_field(field, known_models=known_models)
    return known_models


def _regenerate_error_with_loc(
    *, errors: Sequence[Any], loc_prefix: tuple[str | int, ...]
) -> list[dict[str, Any]]: