}

        @Override
        public long createTime() {
            return 0;
        }

        @Override
        public long lastModified() {
            return 0;
        }

        @Override
        public long lastAccess() {
            return 0;
        }

        @Override
        public long length() {
            return 0;
        }

            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "sortOrder" : {
            "type" : "integer"
          },
          "updatedBy" : {
            "type" : "keyword"
          },
          "updatedTime" : {
            "type" : "long"
          },
          "urlExpr" : {
            "type" : "keyword"
          }
        }
      }

        }

        @Override
        public void sendRedirect(String location) {
        }

        @Override
        public void setDateHeader(String name, long date) {
        }

        @Override
        public void addDateHeader(String name, long date) {
        }

        @Override
        public void addHeader(String name, String value) {
            headers.put(name, value);
        }

      "sortOrder": {
        "type": "integer"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },
      "updatedBy": {
        "type": "keyword"
      },
      "updatedTime": {
        "type": "long"
      },
      "description" : {
        "type": "text",
        "analyzer": "standard_analyzer"
      }
    }

    "aliases" : { },
    "mappings" : {
      "duplicate_host" : {
        "properties" : {
          "createdBy" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "duplicateHostName" : {
            "type" : "keyword"
          },
          "regularName" : {
            "type" : "keyword"
          },
          "sortOrder" : {

        assertEquals(-1L, serverData.serverTime);

        // Test with max value
        serverData.serverTime = Long.MAX_VALUE;
        assertEquals(Long.MAX_VALUE, serverData.serverTime);

        // Test with min value
        serverData.serverTime = Long.MIN_VALUE;
        assertEquals(Long.MIN_VALUE, serverData.serverTime);
    }

    /**
     * Test setting and getting byte array fields
     */

   *
   * @since 20.0 (varargs overload since 2.0)
   */
  public static void checkArgument(
      boolean expression, String errorMessageTemplate, long p1, long p2) {
    if (!expression) {
      throw new IllegalArgumentException(lenientFormat(errorMessageTemplate, p1, p2));
    }
  }

  /**

 */
public class FacetResponse {
    /**
     * Map containing query facet counts, where keys are decoded query strings
     * and values are document counts for each query.
     */
    protected Map<String, Long> queryCountMap = new LinkedHashMap<>();

    /**
     * List of field facets containing aggregated field values and their counts.
     */
    protected List<Field> fieldList = new ArrayList<>();

    /**

            // MSAL4J handles token refresh internally through silent authentication
            // Check if token is still valid by comparing absolute timestamps
            final long tokenExpiryTime = authResult.expiresOnDate().getTime(); // milliseconds since epoch
            final long currentTime = ComponentUtil.getSystemHelper().getCurrentTimeAsLong(); // milliseconds since epoch
            if (tokenExpiryTime < currentTime) {

        ChannelFailover.FailoverState state = new ChannelFailover.FailoverState("test-channel");

        long firstRetry = state.getNextRetryTime();
        state.incrementRetry();

        long secondRetry = state.getNextRetryTime();
        state.incrementRetry();

        long thirdRetry = state.getNextRetryTime();

        // Should have exponential backoff
        assertTrue(secondRetry > firstRetry);