return false;
    }

    @Override
    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
        if ("Lorg/testng/annotations/Test;".equals(desc)) {
            setTest(true);
        }
        return null;
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
        if (!isAbstract() && !isTest()) {

    @SuppressWarnings("deprecation")
    def desc = new LimitedDescription(2)

    def "has limited description"() {
        when:
        desc.append("0").append("one").append("2").append("three !")

        then:
        desc.toString() == """2
three !
"""
    }

    def "is described even when empty"() {
        expect:
        desc.toString().length() != 0
    }

    "experimental-prune-unreachable-nodes-unconditionally",
    llvm::cl::desc("Prune nodes that are not ancestors of the output nodes."),
    llvm::cl::location(experimental_prune_unreachable_nodes_unconditionally),
    llvm::cl::init(false));

// NOLINTNEXTLINE
static opt<std::string> input_arrays_flag(
    "input-arrays",
    llvm::cl::desc(
        "List of input tensors, if different from the default inputs"),

        def log = temp.file("foo.log")
        log << "hey joe!"
        def diagnostics = new DaemonDiagnostics(log, 123)

        when:
        String desc = diagnostics.describe()

        then:
        desc.contains "123"
        desc.contains log.name
        desc.contains "hey joe!"
    }

opt<std::string> input_path(llvm::cl::Positional,
                            llvm::cl::desc("<input path>"), llvm::cl::Required);

// NOLINTNEXTLINE
opt<std::string> output_filename("o", llvm::cl::desc("<output path>"),
                                 llvm::cl::Optional, llvm::cl::init("-"));

// NOLINTNEXTLINE
opt<std::string> input_arg_shapes_str(
    "input-arg-shapes",
    llvm::cl::desc(
        "A string representation of input argument shapes for 'main' "

        }

        @Override
        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
            if (desc.equals(ANNOTATION_DESCRIPTOR)) {
                return new AnnotationTransformingVisitor(super.visitAnnotation(desc, visible));
            }
            return super.visitAnnotation(desc, visible);
        }

        private static class AnnotationTransformingVisitor extends AnnotationVisitor {

                MethodModelRuleDescriptor desc = descriptors.get(weakMethod);
                if (desc != null) {
                    return desc;
                }
                desc = new MethodModelRuleDescriptor(weakMethod);
                // Only cache non-overloaded methods by name
                descriptors.put(weakMethod, desc);
                return desc;
            }
        }
    }

		},
	}

	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()

	for _, tc := range []struct {
		desc             string
		pods             []*v1.Pod
		devices          []*podresourcesv1.ContainerDevices
		expectedResponse *v1alpha1.ListPodResourcesResponse
	}{
		{
			desc:             "no pods",
			pods:             []*v1.Pod{},
			devices:          []*podresourcesv1.ContainerDevices{},

        try {
            PluginDescriptor desc = descriptors.get(key);
            if (desc == null) {
                synchronized (key) {
                    desc = descriptors.get(key);
                    if (desc == null) {
                        desc = supplier.load();
                        descriptors.putIfAbsent(key, clone(desc));
                    }
                }
            }

      ByteSourceFactory factory, String string, String name, String desc) {
    TestSuite suite = suiteForBytes(factory, string.getBytes(Charsets.UTF_8), name, desc, true);
    CharSourceFactory charSourceFactory = SourceSinkFactories.asCharSourceFactory(factory);
    suite.addTest(
        CharSourceTester.suiteForString(
            charSourceFactory, string, name + ".asCharSource[Charset]", desc));
    return suite;
  }