pkg debug/elf, const R_390_TLS_TPOFF = 56
pkg debug/elf, const R_390_TLS_TPOFF R_390
pkg debug/elf, method (R_390) GoString() string
pkg debug/elf, method (R_390) String() string
pkg debug/elf, type R_390 int
pkg encoding/json, method (*Encoder) SetEscapeHTML(bool)
pkg encoding/json, method (*Encoder) SetIndent(string, string)
pkg go/build, type Package struct, BinaryOnly bool

        assertEquals(5000, netServerEnum2.timeout);
    }

    /**
     * Test the reset method.
     */
    @Test
    void testReset() {
        String lastName = "LAST_NAME";
        netServerEnum2.reset(0, lastName);
        assertEquals(lastName, netServerEnum2.lastName);
    }

    /**
     * Test the writeSetupWireFormat method.
     */
    @Test
    void testWriteSetupWireFormat() {

            assertNotNull(clazz.getMethod("getContext"), "Should have getContext method");
            assertNotNull(clazz.getMethod("getName"), "Should have getName method");
            assertNotNull(clazz.getMethod("getType"), "Should have getType method");
            assertNotNull(clazz.getMethod("exists"), "Should have exists method");

    /**
     * @see org.junit.rules.ExpectedException
     */
    @Rule
    public ExpectedException exception = ExpectedException.none();

    /**
     * Test method for
     * {@link org.codelibs.core.io.PropertiesUtil#load(java.util.Properties, java.io.InputStream)}
     * .
     */
    @Test
    public void testLoadPropertiesInputStream() {

        final Map<TypeVariable<?>, Type> map = ParameterizedClassDescFactory.getTypeVariables(Hoge.class);
        final Method method = Hoge.class.getMethod("foo", Set.class, Map.class);
        ParameterizedClassDesc desc = ParameterizedClassDescFactory.createParameterizedClassDesc(method, 0, map);
        assertThat(desc.getRawClass(), is(sameClass(Set.class)));
        ParameterizedClassDesc[] args = desc.getArguments();

    final Method method;

    MethodInvokable(Method method) {
      super(method);
      this.method = method;
    }

    @Override
    final @Nullable Object invokeInternal(@Nullable Object receiver, @Nullable Object[] args)
        throws InvocationTargetException, IllegalAccessException {
      return method.invoke(receiver, args);
    }

    @Override

        // Encrypt with new method, decrypt with old method
        @SuppressWarnings("deprecation")
        final String encrypted1 = cipher.encryptText(original);
        @SuppressWarnings("deprecation")
        final String decrypted1 = cipher.decryptoText(encrypted1);
        assertThat(decrypted1, is(original));

        // Encrypt with old method, decrypt with new method
        @SuppressWarnings("deprecation")

    }

    def method(String name, ClassMetaData classMetaData) {
        return method([:], name, classMetaData)
    }

    def method(Map<String, ?> args, String name, ClassMetaData classMetaData) {
        MethodMetaData method = Mock()
        List<String> paramTypes = args.paramTypes ?: []
        _ * method.name >> name
        _ * method.overrideSignature >> "$name(${paramTypes.join(', ')})"

import com.google.errorprone.annotations.CanIgnoreReturnValue;

/** Static utility method for unchecked throwing of any {@link Throwable}. */
@GwtCompatible
final class SneakyThrows<T extends Throwable> {
  /**
   * Throws {@code t} as if it were an unchecked {@link Throwable}.
   *
   * <p>This method is useful primarily when we make a reflective call to a method with no {@code

        delegate.setAddLocationInformation(false);
    }
    /**
     * Method setFileComment.
     *
     * @param fileComment a fileComment object.
     */
    public void setFileComment(String fileComment) {
        delegate.setFileComment(fileComment);
    }

    /**
     * Method write.
     *
     * @param writer a writer object.
     * @param settings a settings object.