* The supplied request may also refer to a single concrete version rather than a version range.
     * In this case though, the result contains simply the (parsed) input version, regardless of the
     * repositories and their contents.
     *
     * @param session the session to use
     * @param artifactCoordinates t
     * @return the version range resolution result

        timeZone = utc
        set2DigitYearStart(Date(-631152000000L)) // 1950-01-01T00:00:00Z.
      }

    try {
      val parsed = dateFormat.parse(string)
      return parsed.time
    } catch (e: ParseException) {
      throw ProtocolException("Failed to parse UTCTime $string")
    }
  }

  internal fun formatUtcTime(date: Long): String {
    val utc = TimeZone.getTimeZone("GMT")

        }
    }

    /**
     * Gets the content of the response using the provided parser function.
     *
     * @param <T> the type of the parsed content.
     * @param parser the function to parse the content.
     * @return the parsed content.
     */
    public <T> T getContent(final Function<CurlResponse, T> parser) {
        return parser.apply(this);
    }

    /**
     * Gets the content of the response as a string.

  arrayOfNulls<DateFormat>(BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS.size)

/** Returns the date for this string, or null if the value couldn't be parsed. */
fun String.toHttpDateOrNull(): Date? {
  if (isEmpty()) return null

  val position = ParsePosition(0)
  var result = STANDARD_DATE_FORMAT.get().parse(this, position)
  if (position.index == length) {
    // STANDARD_DATE_FORMAT must match exactly; all text must be consumed, e.g. no ignored

   * Returns the last value corresponding to the specified field parsed as an HTTP date, or null if
   * either the field is absent or cannot be parsed as a date.
   */
  fun getDate(name: String): Date? = get(name)?.toHttpDateOrNull()

  /**
   * Returns the last value corresponding to the specified field parsed as an HTTP date, or null if
   * either the field is absent or cannot be parsed as a date.
   */

        // When
        Type3Message parsed = new Type3Message(messageBytes);

        // Then
        // Note: getType() method does not exist, so we cannot compare message types
        assertEquals(original.getDomain(), parsed.getDomain());
        assertEquals(original.getUser(), parsed.getUser());
        assertEquals(original.getWorkstation(), parsed.getWorkstation());
    }

    @Test

			<!-- Supported MIME type -->
			<arg>
  "(application/xml"
+ "|application/xhtml+xml"
+ "|application/rdf+xml"
+ "|application/pdf"
+ "|application/x-freemind"
+ "|text/xml"
+ "|text/xml-external-parsed-entity)"
			</arg>
		</postConstruct>
	</component>

	<component name="fsFileRule" class="org.codelibs.fess.crawler.rule.impl.RegexRule" >
		<property name="ruleId">"fsFileRule"</property>

        // Default constructor
    }

    /**
     * Parses a robots.txt file from the given input stream using UTF-8 encoding.
     * @param stream the input stream to parse
     * @return the parsed RobotsTxt object, or null if disabled
     */
    public RobotsTxt parse(final InputStream stream) {
        return parse(stream, Constants.UTF_8);
    }

    /**

        // Verify parsed data
        Field addressArrayField = NodeStatusResponse.class.getDeclaredField("addressArray");
        addressArrayField.setAccessible(true);
        NbtAddress[] addresses = (NbtAddress[]) addressArrayField.get(response);
        assertNotNull(addresses);
        assertEquals(3, addresses.length);

        // Verify MAC address was parsed

		w := NewWriter(io.Discard)
		for _, f := range files {
			ww, err := w.CreateHeader(f.header)
			if err != nil {
				t.Fatalf("unable to write previously parsed header: %s", err)
			}
			if _, err := ww.Write(f.content); err != nil {
				t.Fatalf("unable to write previously parsed content: %s", err)
			}
		}

		if err := w.Close(); err != nil {
			t.Fatalf("Unable to write archive: %s", err)
		}