{
  "fess_config.crawling_info" : {
    "aliases" : { },
    "mappings" : {
      "crawling_info" : {
        "properties" : {
          "createdTime" : {
            "type" : "long"
          },
          "expiredTime" : {
            "type" : "long"
          },
          "name" : {
            "type" : "keyword"
          },
          "sessionId" : {
            "type" : "keyword"
          }
        }
      }
    },

    assertThat(request.tag(String::class)).isSameAs(stringTag)

    // TODO check for Jvm or handle Long/long correctly
//    assertThat(request.tag(Long::class)).isSameAs(longTag)
  }

  /** Confirm that we don't accidentally share the backing map between objects. */
  @Test
  fun tagsAreImmutable() {
    val builder =
      Request
        .Builder()
        .url("https://square.com")

                this.witnessHeartbeatTimeout = Long.parseLong(value);
            } catch (NumberFormatException e) {
                // Invalid value ignored
            }
        }

        value = props.getProperty("jcifs.smb.client.witnessRegistrationTimeout");
        if (value != null) {
            try {
                this.witnessRegistrationTimeout = Long.parseLong(value);

     * zero and negative capacities.
     */
    @ParameterizedTest
    @ValueSource(longs = { 0L, -1L, Long.MAX_VALUE })
    @DisplayName("capacity may be any long value")
    void testCapacityEdgeValues(long capacity) {
        when(mockAllocInfo.getCapacity()).thenReturn(capacity);
        assertEquals(capacity, mockAllocInfo.getCapacity());
    }

    /**

    /** Time taken for the operation in milliseconds. */
    protected final long took;

    /**
     * Constructor for SuggestDeleteResponse.
     * @param errors A list of Throwables representing errors.
     * @param took The time taken for the operation in milliseconds.
     */
    protected SuggestDeleteResponse(final List<Throwable> errors, final long took) {
        this.took = took;
        if (errors != null && !errors.isEmpty()) {

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

    "aliases" : { },
    "mappings" : {
      "crawling_info_param" : {
        "properties" : {
          "crawlingInfoId" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "key" : {
            "type" : "keyword"
          },
          "value" : {
            "type" : "keyword"
          }
        }
      }
    },
    "settings" : {

        }

        public String getIndex() {
            return "fess.suggest";
        }

        public long getAllWordsNum() {
            return 100L;
        }

        public long getDocumentWordsNum() {
            return 50L;
        }

        public long getQueryWordsNum() {
            return 30L;
        }
    }

    private static class MockSuggestIndexer {

internal fun ServerSocket.closeQuietly() {
  try {
    close()
  } catch (rethrown: RuntimeException) {
    throw rethrown
  } catch (_: Exception) {
  }
}

internal fun Long.toHexString(): String = java.lang.Long.toHexString(this)

internal fun Int.toHexString(): String = Integer.toHexString(this)

internal fun <T> readFieldOrNull(
  instance: Any,
  fieldType: Class<T>,
  fieldName: String,

      // Since index and (dataset.length - 1) are non-negative ints, their product can be expressed
      // as a long, without risk of overflow:
      long numerator = (long) index * (dataset.length - 1);
      // Since scale is a positive int, index is in [0, scale], and (dataset.length - 1) is a
      // non-negative int, we can do long-arithmetic on index * (dataset.length - 1) / scale to get