* Valid values are INSTRUCTION, LINE, BRANCH, COMPLEXITY, METHOD and CLASS. Defaults to INSTRUCTION.
     */
    @Input
    String getCounter();

    /**
     * Sets the counter that applies to the limit.
     *
     * @param counter Counter
     */
    void setCounter(String counter);

    /**
     * The value that applies to the limit as defined by

    private String value = "COVEREDRATIO";
    private BigDecimal minimum;
    private BigDecimal maximum;

    @Override
    public String getCounter() {
        return counter;
    }

    @Override
    public void setCounter(String counter) {
        this.counter = counter;
    }

    @Override
    public String getValue() {
        return value;
    }

    @Override

                                    Map<String, Object> limitArgs = new HashMap<String, Object>();
                                    limitArgs.put("counter", limit.getCounter());
                                    limitArgs.put("value", limit.getValue());

                                    if (limit.getMinimum() != null) {

            abstract class WrapperService implements ${BuildService.name}<${BuildServiceParameters.None.name}> {
                @${ServiceReference.name}('counter')
                abstract Property<CountingService> getCounter()

                public void incrementIndirectly() {
                    counter.get().increment()
                }
            }
            abstract class Consumer extends DefaultTask {

		if mf.GetName() != name {
			continue // Ignore other metrics.
		}
		for _, metric := range mf.GetMetric() {
			if !testutil.LabelsMatch(metric, labelFilter) {
				continue
			}
			counterSum += int(metric.GetCounter().GetValue())
		}
	}
	if wantCount != counterSum {
		t.Errorf("Wanted count %d, got %d for metric %s with labels %#+v", wantCount, counterSum, name, labelFilter)
		for _, mf := range metrics {

            abstract class CountRecorder implements TransformAction<Parameters> {
                interface Parameters extends TransformParameters{
                    @Input
                    Counter getCounter()
                    void setCounter(Counter counter)
                }

                @InputArtifact
                abstract Provider<FileSystemLocation> getInputArtifact()

                CountRecorder() {

		return -1
	}

	for _, mf := range mfs {
		if mf.Name != nil && *mf.Name == name {
			mfMetric := mf.GetMetric()
			for _, m := range mfMetric {
				if m.GetCounter() != nil {
					return int(m.GetCounter().GetValue())
				}
			}
		}
	}

	return -1

		return -1
	}

	for _, mf := range mfs {
		if mf.Name != nil && *mf.Name == name {
			mfMetric := mf.GetMetric()
			for _, m := range mfMetric {
				if m.GetCounter() != nil {
					return int(m.GetCounter().GetValue())
				}
			}
		}
	}

	return -1

}

func TestNetworkGetDataFailures(t *testing.T) {
	netCounter := newFakedNetworkCounters(true)

	_, err := netCounter.getData()
	expectedMsg := "Expected getDataList error."
	if err == nil || err.Error() != expectedMsg {
		t.Fatalf("expected error message `%s` but got `%v`", expectedMsg, err)
	}

	_, err = netCounter.getData()
	netCounter.packetsReceivedPerSecondCounter.(*fakePerfCounterImpl).raiseError = false

func (plugin *iscsiPlugin) NewDeviceMounter() (volume.DeviceMounter, error) {
	return plugin.NewAttacher()
}

func (plugin *iscsiPlugin) GetDeviceMountRefs(deviceMountPath string) ([]string, error) {
	mounter := plugin.host.GetMounter(iscsiPluginName)
	return mounter.GetMountRefs(deviceMountPath)
}

func (attacher *iscsiAttacher) Attach(spec *volume.Spec, nodeName types.NodeName) (string, error) {
	return "", nil
}