} catch (InvocationTargetException e) {
      if (e.getCause() instanceof Error) {
        throw (Error) e.getCause();
      }
      throw e;
    }
  }

  /** Gets the context for the given event. */
  private SubscriberExceptionContext context(Object event) {
    return new SubscriberExceptionContext(bus, event, target, method);
  }

  @Override
  public final int hashCode() {

     */
    public SmbFile(final SmbResource context, final String name) throws MalformedURLException, UnknownHostException {
        this(isWorkgroup(context) ? new URL(null, "smb://" + checkName(name), context.getContext().getUrlHandler())
                : new URL(context.getLocator().getURL(), encodeRelativePath(checkName(name)), context.getContext().getUrlHandler()),

public class SmbComCloseTest {

    private CIFSContext context;
    private PropertyConfiguration config;

    @BeforeEach
    public void setUp() throws CIFSException {
        // Create a mock configuration for testing
        Properties properties = new Properties();
        config = new PropertyConfiguration(properties);
        context = mock(CIFSContext.class);
        when(context.getConfig()).thenReturn(config);
    }

    /**

		return time.Since(cache.lastUpdate) > 5*time.Minute
	}
	return true
}

// keepAlive will continuously update lastHandout until ctx is canceled.
func (m metacache) keepAlive(ctx context.Context, rpc *peerRESTClient) {
	// we intentionally operate on a copy of m, so we can update without locks.
	t := time.NewTicker(metacacheMaxClientWait / 10)
	defer t.Stop()
	for {
		select {
		case <-ctx.Done():

pkg runtime/trace, func IsEnabled() bool
pkg runtime/trace, func Log(context.Context, string, string)
pkg runtime/trace, func Logf(context.Context, string, string, ...interface{})
pkg runtime/trace, func NewTask(context.Context, string) (context.Context, *Task)
pkg runtime/trace, func StartRegion(context.Context, string) *Region
pkg runtime/trace, func WithRegion(context.Context, string, func())
pkg runtime/trace, method (*Region) End()

**Screenshots**
If applicable, add screenshots to help explain your problem.

**Environment (please complete the following information):**
 - OS: [e.g. Windows 10]
 - Version [e.g. 3.5.0]

**Additional context**

			}
		case "Key":
			z.Key, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Key")
				return
			}
		case "Context":
			z.Context, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Context")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

        assertThat(ClassLoaderUtil.getClassLoader(TestCase.class), is(sameInstance(TestCase.class.getClassLoader())));

        final ClassLoader context = Thread.currentThread().getContextClassLoader();
        try {
            final ClassLoader cl = new URLClassLoader(new URL[0], getClass().getClassLoader());
            Thread.currentThread().setContextClassLoader(cl);

type MetricsLoaderFn func(context.Context, MetricValues, *metricsCache) error

// JoinLoaders - joins multiple loaders into a single loader. The returned
// loader will call each of the given loaders in order. If any of the loaders
// return an error, the returned loader will return that error.
func JoinLoaders(loaders ...MetricsLoaderFn) MetricsLoaderFn {
	return func(ctx context.Context, m MetricValues, c *metricsCache) error {

                }

                // Clear encryption context
                if (this.encryptionContext != null) {
                    try {
                        this.encryptionContext = null;
                    } catch (Exception e) {
                        log.debug("Error clearing encryption context during emergency cleanup", e);
                    }
                }
            }