for _, dateFormat := range httpTimeFormats {
		t, err := time.Parse(dateFormat, timeStr)
		if err == nil {
			return t, nil
		}
	}
	return time.Time{}, ErrMalformedDate
}

// ParseReplicationTS parse http.TimeFormat first
// will try time.RFC3339Nano when parse http.TimeFormat failed
func ParseReplicationTS(str string) (time.Time, error) {
	tm, err := time.Parse(http.TimeFormat, str)
	if tm.IsZero() || err != nil {

		log.Fatal("too many errors")
	}
}

func (p *Parser) pos() src.XPos {
	return p.ctxt.PosTable.XPos(src.MakePos(p.lex.Base(), uint(p.lineNum), 0))
}

func (p *Parser) Parse() (*obj.Prog, bool) {
	scratch := make([][]lex.Token, 0, 3)
	for {
		word, cond, operands, ok := p.line(scratch)
		if !ok {
			break
		}
		scratch = operands

		if p.pseudo(word, operands) {

		if err != nil {
			return nil, err
		}

		qosEnv := target.EnvMQTTQoS
		if k != config.Default {
			qosEnv = qosEnv + config.Default + k
		}

		// Parse uint8 value
		qos, err := strconv.ParseUint(env.Get(qosEnv, kv.Get(target.MqttQoS)), 10, 8)
		if err != nil {
			return nil, err
		}

		topicEnv := target.EnvMQTTTopic
		if k != config.Default {

Anis Eleuch <******@****.***> 1712232280 +0100

    }

    public void test_parse() {
        PrunedTag[] tags = PrunedTag.parse("");
        assertEquals(0, tags.length);

        tags = PrunedTag.parse("a");
        assertEquals(1, tags.length);
        assertEquals("PrunedTag [tag=a, id=null, css=null, attrName=null, attrValue=null]", tags[0].toString());

        tags = PrunedTag.parse("a#test");
        assertEquals(1, tags.length);

    assertThat(parse("http:\\/host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:/\\host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:\\\\host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:///host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:\\//host/path"))
      .isEqualTo(parse("http://host/path"))

        parameters = "";
        parameterMap = ParameterUtil.parse(parameters);
        assertEquals(0, parameterMap.size());

        parameters = "domain";
        parameterMap = ParameterUtil.parse(parameters);
        assertEquals(1, parameterMap.size());
        assertEquals("", parameterMap.get("domain"));

        parameters = "domain=";
        parameterMap = ParameterUtil.parse(parameters);
        assertEquals(1, parameterMap.size());

     */
    @Nonnull
    Model parse(@Nonnull Source source, @Nullable Map<String, ?> options) throws ModelParserException;

    /**
     * Locate and parse the model in the specified directory.
     * This is equivalent to {@code locate(dir).map(s -> parse(s, options))}.
     *
     * @param dir the directory to locate the pom for, never {@code null}

  @Test fun invalidCharacters() {
    assertThat(parse(url, "a\u0000b=cd")).isNull()
    assertThat(parse(url, "ab=c\u0000d")).isNull()
    assertThat(parse(url, "a\u0001b=cd")).isNull()
    assertThat(parse(url, "ab=c\u0001d")).isNull()
    assertThat(parse(url, "a\u0009b=cd")).isNull()
    assertThat(parse(url, "ab=c\u0009d")).isNull()
    assertThat(parse(url, "a\u001fb=cd")).isNull()
    assertThat(parse(url, "ab=c\u001fd")).isNull()

class WebSocketExtensionsTest {
  @Test
  fun emptyHeader() {
    assertThat(parse("")).isEqualTo(WebSocketExtensions())
  }

  @Test
  fun noExtensionHeader() {
    assertThat(WebSocketExtensions.parse(headersOf()))
      .isEqualTo(WebSocketExtensions())
  }

  @Test
  fun emptyExtension() {
    assertThat(parse(", permessage-deflate"))