out = append(out, svcs...)
	}
	return model.SortServicesByCreationTime(out)
}

func (s *serviceStore) getServices(key types.NamespacedName) []*model.Service {
	return s.servicesBySE[key]
}

func (s *serviceStore) deleteServices(key types.NamespacedName) {
	delete(s.servicesBySE, key)
}

func (s *serviceStore) updateServices(key types.NamespacedName, services []*model.Service) {
	s.servicesBySE[key] = services

	gotInstances = store.getAll()
	if len(gotInstances) != 0 {
		t.Errorf("got unexpected instances %v", gotSeInstances)
	}
}

func TestServiceStore(t *testing.T) {
	store := serviceStore{
		servicesBySE: map[types.NamespacedName][]*model.Service{},
	}

	expectedServices := []*model.Service{

 * for their scope and its children.
 *
 * @see Scope
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface ServiceScope {

    /**
     * One or more scopes in which the service is declared,
     * from the longest lifecycle to the shortest.
     */
    Class<? extends Scope>[] value();

// OpenRCInitSystem defines openrc
type OpenRCInitSystem struct{}

// ServiceStart tries to start a specific service
func (openrc OpenRCInitSystem) ServiceStart(service string) error {
	args := []string{service, "start"}
	return exec.Command("rc-service", args...).Run()
}

// ServiceStop tries to stop a specific service
func (openrc OpenRCInitSystem) ServiceStop(service string) error {
	args := []string{service, "stop"}

type InitSystem interface {
	// EnableCommand returns a string describing how to enable a service
	EnableCommand(service string) string

	// ServiceStart tries to start a specific service
	ServiceStart(service string) error

	// ServiceStop tries to stop a specific service
	ServiceStop(service string) error

	// ServiceRestart tries to reload the environment and restart the specific service
	ServiceRestart(service string) error

func (sysd WindowsInitSystem) ServiceRestart(service string) error {
	if err := sysd.ServiceStop(service); err != nil {
		return errors.Wrapf(err, "couldn't stop service %s", service)
	}
	if err := sysd.ServiceStart(service); err != nil {
		return errors.Wrapf(err, "couldn't start service %s", service)
	}

	return nil
}

// ServiceStop tries to stop a specific service

 * <p>
 * Only services that are annotated with {@link ServiceScope} are validated.
 */
@NonNullApi
class ServiceScopeValidator implements AnnotatedServiceLifecycleHandler {

    private static final List<Class<? extends Annotation>> SCOPE_ANNOTATIONS = Collections.<Class<? extends Annotation>>singletonList(ServiceScope.class);

    private final Class<? extends Scope> scope;
    private final boolean strict;

        return new ScopedServiceRegistry(scope, strict, "test service registry")
    }

    @ServiceScope(Scope.BuildTree)
    static class BuildTreeScopedService {}

    @ServiceScope([Scope.Global, Scope.Build])
    static class GlobalAndBuildScopedService {}

    static class UnscopedService {}

     * validate all registered services for being annotated with the given scope.
     * <p>
     * However, this still allows to register services without the
     * {@link org.gradle.internal.service.scopes.ServiceScope @ServiceScope} annotation.
     *
     * @see #scopeStrictly(Class)
     */
    public ServiceRegistryBuilder scope(Class<? extends Scope> scope) {
        this.scope = scope;
        this.strict = false;

 * limitations under the License.
 */

package org.gradle.internal.scripts;

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface ScriptFileResolverListeners {

    void addListener(ScriptFileResolvedListener scriptFileResolvedListener);