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

        form.doc.put("title", "Test");

        final java.lang.reflect.Field currentFormField = AdminSearchlistAction.class.getDeclaredField("currentForm");
        currentFormField.setAccessible(true);
        currentFormField.set(action, form);

        // Set fessConfig via reflection
        final java.lang.reflect.Field fessConfigField = findField(action.getClass(), "fessConfig");

              <exclude>%regex[.*PackageSanityTests.*.class]</exclude>
              <!-- FeatureUtilTest.*ExampleDerivedInterfaceTester, com.google.common.io.*Tester, incidentally FeatureSpecificTestSuiteBuilderTest.MyAbstractTester (but we don't care either way because it's not meant to run on its own but works OK if it does)... but not NullPointerTesterTest, etc. -->
              <exclude>%regex[.*Tester.class]</exclude>

 * the License.
 */

package com.google.common.reflect;

import java.lang.reflect.GenericArrayType;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.HashSet;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.Arrays;
import org.jspecify.annotations.Nullable;

/**
 * Wrapper around either a {@link Method} or a {@link Constructor}. Convenience API is provided to

package callbacks

import (
	"reflect"

	"gorm.io/gorm"
)

func callMethod(db *gorm.DB, fc func(value interface{}, tx *gorm.DB) bool) {
	tx := db.Session(&gorm.Session{NewDB: true})
	if called := fc(db.Statement.ReflectValue.Interface(), tx); !called {
		switch db.Statement.ReflectValue.Kind() {
		case reflect.Slice, reflect.Array:
			db.Statement.CurDestIndex = 0
			for i := 0; i < db.Statement.ReflectValue.Len(); i++ {

package schema

import (
	"reflect"
	"sync"
)

// sync pools
var (
	normalPool      sync.Map
	poolInitializer = func(reflectType reflect.Type) FieldNewValuePool {
		v, _ := normalPool.LoadOrStore(reflectType, &sync.Pool{
			New: func() interface{} {
				return reflect.New(reflectType).Interface()
			},
		})
		return v.(FieldNewValuePool)
	}

	}

	for i, testCase := range testCases {
		result := testCase.set.Clone()

		if !reflect.DeepEqual(result, testCase.set) {
			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.set, result)
		}

		result.add(testCase.targetIDToAdd)
		if reflect.DeepEqual(result, testCase.set) {
			t.Fatalf("test %v: result: expected: not equal, got: equal", i+1)
		}
	}
}