* governing permissions and limitations under the License.
 */
package org.codelibs.core.misc;

/**
 * A class that holds a value.
 *
 * @author koichik
 * @param <T>
 *            The type of the value
 */
public class ValueHolder<T> {

    /** The value */
    protected T value;

    /**
     * Constructs an instance.
     */
    public ValueHolder() {
    }

import org.gradle.api.Task;
import org.gradle.api.provider.ProviderFactory;
import org.gradle.api.tasks.TaskProvider;

import javax.inject.Inject;
import java.util.stream.Collectors;

public class FilePermissionsPrecommitPlugin extends PrecommitPlugin implements InternalPlugin {

    public static final String FILEPERMISSIONS_TASK_NAME = "filepermissions";
    private ProviderFactory providerFactory;

    @Inject

/**
 * A dictionary creator for stopwords files.
 * This class is responsible for creating {@link StopwordsFile} instances
 * from files that match the pattern "stopwords.*\\.txt".
 */
public class StopwordsCreator extends DictionaryCreator {
    private static final Logger logger = LogManager.getLogger(StopwordsCreator.class);

    /**
     * Constructs a new creator for stopwords dictionaries.

import org.codenarc.rule.AbstractAstVisitor;
import org.codenarc.util.AstUtil;

public class IntegrationTestFixtureVisitor extends AbstractAstVisitor {

    /**
     * Determines if the class is an integration test. It's a bit weak, but we cannot
     * rely on the class node analysis since it doesn't give the right superclass because
     * resolution is not complete when this visitor is executed.
     */

    }
  }

  @Override
  protected void tearDown() {
    stack.runTearDown();
  }

  static final Exception EXCEPTION = new Exception();

  static final class ExampleClassUnderTest {
    static final Logger logger = Logger.getLogger(ExampleClassUnderTest.class.getName());

    static void foo() {
      logger.log(Level.INFO, "message", EXCEPTION);
    }

    private ExampleClassUnderTest() {}
  }

import java.util.Collections;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * Encapsulates the constraints that a class under test must satisfy in order for a tester method to
 * be run against that class.
 *
 * @author George van den Driessche
 */
@GwtCompatible
public final class TesterRequirements {
  private final Set<Feature<?>> presentFeatures;
  private final Set<Feature<?>> absentFeatures;

mvn license:format                    # Apply license headers
mvn verify                            # Generate coverage report
```

## Code Conventions

### Class Structure

- **Utility classes**: `abstract` class + `protected` constructor
- **Constants classes**: Same pattern

### Argument Validation

Use `AssertionUtil` at method entry:
- `AssertionUtil.assertArgumentNotNull("argName", value)`

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

sealed class SocketMode

object Channel : SocketMode() {
  override fun toString(): String = "Channel"
}

object Standard : SocketMode() {
  override fun toString(): String = "Standard"
}

data class TlsInstance(
  val provider: Provider,
  val protocol: Protocol,
  val tlsVersion: TlsVersion,

        Field field = DefaultArtifactDescriptorReader.class.getDeclaredField("artifactResolver");
        field.setAccessible(true);
        field.set(pomReader, resolver);

        projectBuilder = getContainer().lookup(ProjectBuilder.class, "classpath");
    }

    @Test
    void testProjectClasspath() throws Exception {

 *
 */
public class AdminDictKuromojiAction extends FessAdminAction {

    /**
     * Default constructor.
     */
    public AdminDictKuromojiAction() {
        super();
    }

    /** The role for this action. */
    public static final String ROLE = "admin-dict";

    private static final Logger logger = LogManager.getLogger(AdminDictKuromojiAction.class);