/**
     * Stores information to the virtual file system that we have learned about.
     *
     * Complete information, like {@link FileSystemLocationSnapshot}s, are not touched nor replaced.
     */
    @CheckReturnValue
    FileSystemNode store(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, MetadataSnapshot snapshot, SnapshotHierarchy.NodeDiffListener diffListener);

    /**

    return failure();
  }

  if (auto attr = mlir::dyn_cast<FlatSymbolRefAttr>(f)) {
    return attr;
  }

  op.emitOpError() << "'s attribute '" << kCalledFuncAttrName
                   << "' is neither StringAttr nor FlatSymbolRefAttr";
  return failure();
}

}  // namespace TF

// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

            return versionsFrom(coverage.value().newInstance(target, target).call() as List)
        } else {
            throw new RuntimeException("Target class '$target' is not annotated with @${TargetVersions.simpleName} nor with @${TargetCoverage.simpleName}.")
        }
    }

    @Override
    protected boolean isAvailable(DefaultVersionedTool version) {
        return true
    }

    @Override

        # possibly modified.
        #
        # NB: a `for` loop captures its iteration list before it begins, so
        # changing the positional parameters here affects neither the number of
        # iterations, nor the values presented in `arg`.
        shift                   # remove old arg
        set -- "$@" "$arg"      # push replacement arg
    done
fi

    Compiler<JavaCompileSpec> delegate = Stub(Compiler)

    AnnotationProcessorDiscoveringCompiler compiler = new AnnotationProcessorDiscoveringCompiler(delegate, detector)

    def "when neither processor path nor processor option are given, no processors are used"() {
        when:
        compiler.execute(spec)
        then:
        spec.effectiveAnnotationProcessors == [] as Set
    }

/**
 * A source Kotlin DSL program can be:
 * - empty
 * - a single buildscript block
 * - a single plugins block
 * - a buildscript block followed by a plugins block
 * - a script with neither a buildscript nor a plugins block
 * - a script preceded by a buildscript or plugins block or both
 *
 * The evaluation of a Kotlin DSL program happens, in the general case, in
 * [two stages](https://en.wikipedia.org/wiki/Multi-stage_programming):

			wsstream.IsWebSocketRequestWithStreamCloseProtocol)
		translatingHandler.ServeHTTP(nil, req)
		if !delegate.served && !translator.served {
			t.Errorf("unexpected neither translator nor delegate served")
			continue
		}
		if test.expectTranslator {
			if !translator.served {
				t.Errorf("%s: expected translator served, got delegate served", name)
			}
		} else if !delegate.served {

func (f *FakeIPVS) AddRealServer(serv *utilipvs.VirtualServer, dest *utilipvs.RealServer) error {
	if serv == nil || dest == nil {
		return fmt.Errorf("failed to add destination for service, neither service nor destination shouldn't be nil")
	}
	key := toServiceKey(serv)
	if _, ok := f.Services[key]; !ok {
		return fmt.Errorf("failed to add destination for service %v, service not found", key.String())
	}

        classFile.isFile()
        testClassFile.isFile()
        testResults.isDirectory()

        and:
        assertTestsExecuted("ThingTest", "ok")
    }

    def "build on Groovy project without sources nor groovy dependency"() {
        given:
        def configurationCache = newConfigurationCacheFixture()
        buildFile << """
            plugins { id 'groovy' }
        """

        when: