/** Log type constant for hourly search count aggregation. */
    public static final String LOG_TYPE_SEARCH_COUNT_HOUR = "search_count_hour_agg";

    /** Log type constant for daily search count aggregation. */
    public static final String LOG_TYPE_SEARCH_COUNT_DAY = "search_count_day_agg";

    /** Log type constant for hourly unique user aggregation. */

     * information to search engines and may not correlate exactly to how often
     * they crawl the page. Valid values are:
     * <ul>
     * <li>always</li>
     * <li>hourly</li>
     * <li>daily</li>
     * <li>weekly</li>
     * <li>monthly</li>
     * <li>yearly</li>
     * <li>never</li>
     * </ul>
     * The value "always" should be used to describe documents that change each

		{1 * time.Hour, "my_download_url", "1 hour before the latest release"},
		{61 * time.Minute, "my_download_url", "1 hour before the latest release"},
		{122 * time.Minute, "my_download_url", "2 hours before the latest release"},
		{24 * time.Hour, "my_download_url", "1 day before the latest release"},
		{25 * time.Hour, "my_download_url", "1 day before the latest release"},

	now := time.Now()
	l.forwardTo(now)

	nowIdx := now.Hour()
	l.Bins[nowIdx] = l.Bins[nowIdx].add(ts)
}

// forwardTo moves time to t, clearing entries between last update and t.
func (l *lastDayTierStats) forwardTo(t time.Time) {
	if t.IsZero() {
		t = time.Now()
	}

	since := t.Sub(l.UpdatedAt).Hours()
	// within the hour since l.UpdatedAt
	if since < 1 {
		return
	}

                            policy = daily { hour = triggerHour },
                            pendingChangesOnly = true,
                        )
                    }

                else -> {
                    schedule {
                        scheduledTrigger(
                            branch,
                            policy = daily { hour = triggerHour },

        final URL url = new File("/Program File").toURI().toURL();
        assertEquals("file:" + getRoot() + "Program File", ResourceUtil.toExternalForm(url));
    }

    /**
     * @throws Exception
     */
    public void testGetFileName() throws Exception {
        URL url = new File("/Program File").toURI().toURL();
        assertEquals(getRoot() + "Program File", ResourceUtil.getFileName(url));

    /**
     * @throws Exception
     */
    public void testToJarFilePath() throws Exception {
        final File f = new File("/Program Files/foo.jar");
        final URL url = new URL("jar:" + f.toURI().toURL() + "!/");
        final String root = new File("/").getCanonicalPath();
        assertEquals(root + "Program Files" + File.separator + "foo.jar", JarFileUtil.toJarFilePath(url));
    }

    /**
     * @throws Exception

            "Last-Modified",
            formatDate(-1, TimeUnit.HOURS)!!,
            "Expires",
            formatDate(1, TimeUnit.HOURS)!!,
          ),
        body = "ABC.1",
      ),
    )
    server.enqueue(
      MockResponse(
        headers =
          headersOf(
            "Last-Modified",
            formatDate(-1, TimeUnit.HOURS)!!,
            "Expires",

		m1 += time.Month(12 * y1)
		m2 += time.Month(12 * y2)

		return FromInt(int64(m2 - m1)), nil
	case timePartDay:
		return FromInt(int64(duration / (24 * time.Hour))), nil
	case timePartHour:
		hours := duration / time.Hour
		return FromInt(int64(hours)), nil
	case timePartMinute:
		minutes := duration / time.Minute
		return FromInt(int64(minutes)), nil
	case timePartSecond:
		seconds := duration / time.Second

      assertThat(response.protocol).isEqualTo(Protocol.HTTP_1_1)
    }
  }

  @Test
  fun testUrlConnectionDirect() {
    testRequest {
      val url = URI(mockServer.endpoint + "/person?name=peter").toURL()

      val connection = url.openConnection() as HttpURLConnection

      assertThat(
        connection.inputStream
          .source()
          .buffer()
          .readUtf8(),