if (onlyIfCached) append("only-if-cached, ")
        if (noTransform) append("no-transform, ")
        if (immutable) append("immutable, ")
        if (isEmpty()) return ""
        deleteRange(length - 2, length)
      }
    headerValue = result
  }
  return result
}

internal fun Long.commonClampToInt(): Int =
  when {
    this > Int.MAX_VALUE -> Int.MAX_VALUE

        assertEquals(LoginModuleControlFlag.REQUIRED, e.getControlFlag(), "Control flag should be REQUIRED");
        assertNotNull(e.getOptions(), "Options map should not be null");
        assertTrue(e.getOptions().isEmpty(), "Default options should be empty");
    }

    @ParameterizedTest
    @NullSource
    @ValueSource(strings = { "", "svc/******@****.***" })
    @DisplayName("Name parameter is ignored (null/empty/arbitrary)")

    }

    private static <T> List<T> copyList(List<T> original) {
        List<T> copy = null;

        if (original != null) {
            copy = new ArrayList<>();

            if (!original.isEmpty()) {
                copy.addAll(original);
            }
        }

        return copy;
    }

        if (request.getLocalRepositoryPath() != null) {
            localRepositoryPath = request.getLocalRepositoryPath().getAbsolutePath();
        }

        if (localRepositoryPath == null || localRepositoryPath.isEmpty()) {
            String path = request.getUserProperties().getProperty(Constants.MAVEN_USER_CONF);
            if (path == null) {

        assertFalse(manager.isUseMultiChannel());
    }

    @Test
    void testGetHealthyChannels() throws UnknownHostException {
        assertTrue(channelManager.getHealthyChannels().isEmpty());

        // Add a healthy channel manually for testing
        InetAddress addr = InetAddress.getByName("192.168.1.100");
        NetworkInterfaceInfo localInterface = new NetworkInterfaceInfo(addr, 1000);

    }

    @Override
    public String getContentType(final InputStream is, final Map<String, String> params) {
        final String filename = params.get(ExtractData.RESOURCE_NAME_KEY);
        if (StringUtil.isEmpty(filename) && is == null) {
            throw new MimeTypeException("Cannot detect MIME type: both filename and input stream are empty. At least one is required.");
        }

        final Metadata metadata = new Metadata();

        if (body.documents == null) {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, "documents is required."));
        }
        if (body.documents.isEmpty()) {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, "documents is empty."));
        }
        final String indexFieldId = fessConfig.getIndexFieldId();

        Model model = builder.build(session, project, Sources.buildSource(file));

        assertNotNull(model);
        assertTrue(model.getProfiles().isEmpty());
    }

    @Test
    void testScmInheritance() throws Exception {
        Model model = Model.newBuilder()
                .scm(Scm.newBuilder()

          @Override
          public @Nullable Object getIfPresent(Object key) {
            return null;
          }
        };

    assertThat(cache.getAllPresent(ImmutableList.of(new Object()))).isEmpty();
  }

  public void testGetAllPresent_cached() {
    Object cachedKey = new Object();
    Object cachedValue = new Object();
    Cache<Object, Object> cache =
        new AbstractCache<Object, Object>() {

        if (rev != null || timestamp != null) {
            msg += " (";
            msg += (rev != null ? rev : "");
            if (timestamp != null && !timestamp.isEmpty()) {
                String ts = formatTimestamp(Long.parseLong(timestamp));
                msg += (rev != null ? "; " : "") + ts;
            }
            msg += ")";
        }
        return msg;
    }