emptyAllocatable := &storage.CSINode{
		ObjectMeta: metav1.ObjectMeta{
			Name: "foo",
		},
		Spec: storage.CSINodeSpec{
			Drivers: []storage.CSINodeDriver{
				{
					Name:         "valid-driver-name",
					NodeID:       "valid-node",
					TopologyKeys: []string{"company.com/zone1", "company.com/zone2"},
				},
			},
		},
	}

	volumeLimitsCases := []struct {
		name     string
		obj      *storage.CSINode

        long nodeId = decoder.readSmallLong();
        if (decoder.readBoolean()) {
            readVariantData(decoder, visitor, nodeId);
        } else {
            readVariantReference(decoder, visitor, nodeId);
        }
    }

    private void readVariantReference(Decoder decoder, ResolvedComponentVisitor visitor, long nodeId) throws IOException {

    public Optional<Model> getRawModel(String modelId) {
        return Optional.ofNullable(rawModels.get(modelId));
    }

    public DefaultModelBuilderResult setRawModel(String modelId, Model rawModel) {
        // Intentionally notNull because Super POM may not contain a modelId
        Objects.requireNonNull(modelId, "modelId cannot be null");

        rawModels.put(modelId, rawModel);

        return this;
    }

    private final String modelId;
    private final String location;
    private final List<InputSource> inputs;

    public InputSource(String modelId, String location) {
        this.modelId = modelId;
        this.location = location;
        this.inputs = null;
    }

    public InputSource(Collection<InputSource> inputs) {
        this.modelId = null;
        this.location = null;

			t.Errorf("error getting CSINode: %v", err)
			continue
		}

		driver := nodeInfo.Spec.Drivers[0]
		if driver.Name != driverName || driver.NodeID != nodeID {
			t.Errorf("expected Driver to be %q and NodeID to be %q, but got: %q:%q", driverName, nodeID, driver.Name, driver.NodeID)
		}
	}
}

func getClientSet(existingNode *v1.Node, existingCSINode *storage.CSINode) *fake.Clientset {
	objects := []runtime.Object{}

    }

    private int assertValidId(int codecId) {
        assert codecId >= 0 : "Module source must have a strictly positive source id";
        return codecId;
    }

    @Override
    public ModuleSources read(Decoder decoder) throws IOException {
        MutableModuleSources sources = new MutableModuleSources();
        int codecId;
        while ((codecId = decoder.readSmallInt()) > 0) {

        public XmlReaderRequestBuilder strict(boolean strict) {
            this.strict = strict;
            return this;
        }

        public XmlReaderRequestBuilder modelId(String modelId) {
            this.modelId = modelId;
            return this;
        }

        public XmlReaderRequestBuilder location(String location) {
            this.location = location;
            return this;
        }

        if (model != null) {
            DefaultModelBuildingResult tmp = new DefaultModelBuildingResult();
            if (modelId == null) {
                modelId = "";
            }
            tmp.addModelId(modelId);
            tmp.setRawModel(modelId, model);
            tmp.setProblems(problems);
            result = tmp;
        } else {
            result = null;
        }
    }

    /**

    }

    @Override
    public Model getRawModel(String modelId) {
        return rawModels.get(modelId);
    }

    public DefaultModelBuildingResult setRawModel(String modelId, Model rawModel) {
        // Intentionally notNull because Super POM may not contain a modelId
        Objects.requireNonNull(modelId, "modelId cannot null");

        rawModels.put(modelId, rawModel);

        return this;
    }

    return;
  }

  // Emit warnings for path.
  int node_idx = 0;
  for (auto iter = path.rbegin(); iter != path.rend(); ++iter) {
    Operation* op = *iter;
    std::string pos_str;
    if (node_idx == 0) {
      pos_str = "source";
    } else if (node_idx + 1 == path.size()) {
      pos_str = "target";
    } else {
      pos_str = "intermediate";
    }