quitCh     chan struct{}
}

// ID - returns target ID.
func (target *KafkaTarget) ID() event.TargetID {
	return target.id
}

// Name - returns the Name of the target.
func (target *KafkaTarget) Name() string {
	return target.ID().String()
}

// Store returns any underlying store if set.
func (target *KafkaTarget) Store() event.TargetStore {
	return target.store
}

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

    }

    @Internal
    public DirectoryProperty getSourceDirectory() {
        return sourceDirectory;
    }

    @Nested
    public List<RestTestTransform<?>> getTransformations() {
        return transformations;
    }

    @Input
    public String getSkippedTestByFilePatternTransformations() {
        return skippedTestByFilePatternTransformations.keySet().stream()

            delegate.addExcludes(excludes);
        }

        return new ExclusionSetFilter(excludes);
    }

    /**
     * Returns the artifact filter for the standard core artifacts.
     *
     * @see org.apache.maven.ArtifactFilterManager#getCoreArtifactFilter()
     */
    @Override
    public ArtifactFilter getCoreArtifactFilter() {
        return new ExclusionSetFilter(getCoreArtifactExcludes());
    }

		return nil
	}

	return objLayer
}

// ClusterCheckHandler returns if the server is ready for requests.
func ClusterCheckHandler(w http.ResponseWriter, r *http.Request) {
	ctx := newContext(r, w, "ClusterCheckHandler")

	objLayer := checkHealth(w)
	if objLayer == nil {
		return
	}

	ctx, cancel := context.WithTimeout(ctx, globalAPIConfig.getClusterDeadline())
	defer cancel()

    }

    /**
     * Test that getTree() returns the correct SmbTreeHandle.
     */
    @Test
    void testGetTree() {
        when(smbFileHandle.getTree()).thenReturn(smbTreeHandle);
        SmbTreeHandle result = smbFileHandle.getTree();
        assertEquals(smbTreeHandle, result, "getTree should return the mocked SmbTreeHandle.");
        verify(smbFileHandle, times(1)).getTree();
    }

  /**
   * Asserts that the current response was redirected and returns the prior response.
   */
  fun priorResponse(): RecordedResponse {
    val priorResponse = response!!.priorResponse!!
    return RecordedResponse(priorResponse.request, priorResponse, null, null, null)
  }

  /**
   * Asserts that the current response used the network and returns the network response.
   */
  fun networkResponse(): RecordedResponse {

	for {
		time.Sleep(time.Hour)

		l.Lock()
		l.IDMap = make(map[string]onceErr)
		l.Unlock()
	}
}

// Returns logOnceType
func newLogOnceType() *logOnceType {
	l := &logOnceType{IDMap: make(map[string]onceErr)}
	go l.cleanupRoutine()
	return l
}

var logOnce = newLogOnceType()

// LogOnceIf - Logs notification errors - once per error.

    inverse = forward;
  }

  @Override
  protected Map<K, V> delegate() {
    return delegate;
  }

  /** Returns its input, or throws an exception if this is not a valid key. */
  @CanIgnoreReturnValue
  @ParametricNullness
  K checkKey(@ParametricNullness K key) {
    return key;
  }

  /** Returns its input, or throws an exception if this is not a valid value. */
  @CanIgnoreReturnValue

     * This method returns the concrete FessUserBean class instead of the generic type.
     *
     * @return an optional containing the current user bean, or empty if not logged in
     */
    @Override
    protected OptionalThing<FessUserBean> getUserBean() { // to return as concrete class
        return fessLoginAssist.getSavedUserBean();
    }

    /**