}

	for k, v := range tags {
		if string(removeSettingFromTag(reflect.StructTag(k), "column")) != v {
			t.Errorf("%v after removeSettingFromTag should equal %v, but got %v", k, v, removeSettingFromTag(reflect.StructTag(k), "column"))
		}
	}

			var v interface{} = callbacks.Create()
			callMethod := func(s interface{}, name string, args ...interface{}) {
				var argValues []reflect.Value
				for _, arg := range args {
					argValues = append(argValues, reflect.ValueOf(arg))
				}

				results := reflect.ValueOf(s).MethodByName(name).Call(argValues)
				if len(results) > 0 {
					v = results[0].Interface()
				}
			}

			if c.name == "" {

    public void test_class_is_public() {
        assertTrue("Class should be public", java.lang.reflect.Modifier.isPublic(SystemMonitorTarget.class.getModifiers()));
        assertFalse("Class should not be abstract", java.lang.reflect.Modifier.isAbstract(SystemMonitorTarget.class.getModifiers()));
        assertFalse("Class should not be final", java.lang.reflect.Modifier.isFinal(SystemMonitorTarget.class.getModifiers()));
    }

pkg net/netip, type Prefix struct
pkg reflect, const Pointer = 22
pkg reflect, const Pointer Kind
pkg reflect, func PointerTo(Type) Type
pkg reflect, method (*MapIter) Reset(Value)
pkg reflect, method (Value) CanComplex() bool
pkg reflect, method (Value) CanFloat() bool
pkg reflect, method (Value) CanInt() bool
pkg reflect, method (Value) CanUint() bool
pkg reflect, method (Value) FieldByIndexErr([]int) (Value, error)

import com.google.common.base.Throwables;
import com.google.common.reflect.AbstractInvocationHandler;
import com.google.common.reflect.Reflection;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;

        closeFlagsField.setAccessible(true);
        int finalFlags = (int) closeFlagsField.get(request);
        assertEquals(0x0000, finalFlags);

        // Verify wire format reflects final state
        byte[] buffer = new byte[256];
        request.writeBytesWireFormat(buffer, 0);

        assertEquals(0x0000, SMBUtil.readInt2(buffer, 2));
        byte[] wireFileId = new byte[16];

        });

        // Check that the root cause is CIFSException
        assertTrue(exception instanceof java.lang.reflect.InvocationTargetException);
        Throwable cause = ((java.lang.reflect.InvocationTargetException) exception).getCause();
        assertTrue(cause instanceof CIFSException);
        assertTrue(cause.getMessage().contains("Failed to create multi-channel transport"));
    }

    @Test

pkg path/filepath, func Localize(string) (string, error) #57151
pkg reflect, func SliceAt(Type, unsafe.Pointer, int) Value #61308
pkg reflect, method (Value) Seq() iter.Seq[Value] #66056
pkg reflect, method (Value) Seq2() iter.Seq2[Value, Value] #66056
pkg reflect, type Type interface, CanSeq() bool #66056
pkg reflect, type Type interface, CanSeq2() bool #66056
pkg reflect, type Type interface, OverflowComplex(complex128) bool #60427

 * limitations under the License.
 */

package com.google.common.reflect;

import static org.junit.Assert.assertThrows;

import com.google.common.testing.EqualsTester;
import com.google.common.testing.NullPointerTester;
import java.lang.reflect.Method;
import java.lang.reflect.TypeVariable;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**

import java.io.Serializable;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Array;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.GenericDeclaration;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;