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()));
    }

    @Test

			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 == "" {

import static java.lang.reflect.Modifier.PRIVATE;
import static java.lang.reflect.Modifier.PROTECTED;
import static java.lang.reflect.Modifier.PUBLIC;
import static java.util.Arrays.asList;

import com.google.common.base.Optional;
import com.google.common.reflect.ClassPath;
import com.google.common.reflect.ClassPath.ClassInfo;
import com.google.common.reflect.TypeToken;
import java.lang.reflect.Method;

		}
		return
	}
}

type visitMap = map[reflect.Value]bool

// Check if circular values, return true if loaded
func loadOrStoreVisitMap(visitMap *visitMap, v reflect.Value) (loaded bool) {
	if v.Kind() == reflect.Ptr {
		v = v.Elem()
	}

	switch v.Kind() {
	case reflect.Slice, reflect.Array:
		loaded = true
		for i := 0; i < v.Len(); i++ {

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.lang.reflect.Field;
import java.util.Arrays;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;

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)

                // Set required fields
                try {
                    java.lang.reflect.Field styleField = NetworkExplorer.class.getDeclaredField("style");
                    styleField.setAccessible(true);
                    styleField.set(this, "test_style");

                    java.lang.reflect.Field transportContextField = NetworkExplorer.class.getDeclaredField("transportContext");

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

        });

        // 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

            receivedMessage.set(error.getMessage());
        });

        // First reject
        deferred.reject(new RuntimeException("first"));
        // Second reject (should be ignored)
        deferred.reject(new RuntimeException("second"));
        // Third reject (should be ignored)
        deferred.reject(new RuntimeException("third"));

        Thread.sleep(100);