#423

Committed 17 Dec 2025 10:33AM UTC coverage: 56.982% (-1.0%) from 57.972%

Build # #423

Build Type

push

github

Committed by

web-flow

Commit Message

refresh 2025-12 (including extensions) (#218)

* "id" is a required field in for Parameters and WorkflowSteps
* regen; drop CommandLineBindableImpl; add optional CWL extensions

Run Details

185 of 577 new or added lines in 21 files covered. (32.06%)

10 existing lines in 10 files now uncovered.

7892 of 13850 relevant lines covered (56.98%)

0.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

41.67

/src/main/java/org/commonwl/cwlsdk/cwl1_2/CUDARequirementImpl.java

// Copyright Common Workflow Language project contributors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package org.commonwl.cwlsdk.cwl1_2;

import org.commonwl.cwlsdk.cwl1_2.utils.LoaderInstances;
import org.commonwl.cwlsdk.cwl1_2.utils.LoadingOptions;
import org.commonwl.cwlsdk.cwl1_2.utils.LoadingOptionsBuilder;
import org.commonwl.cwlsdk.cwl1_2.utils.SaveableImpl;
import org.commonwl.cwlsdk.cwl1_2.utils.ValidationException;

/**
* Auto-generated class implementation for <I>http://commonwl.org/cwltool#CUDARequirement</I><BR> <BLOCKQUOTE>
 Require support for NVIDA CUDA (GPU hardware acceleration).
  </BLOCKQUOTE>
 */
public class CUDARequirementImpl extends SaveableImpl implements CUDARequirement {
  private LoadingOptions loadingOptions_ = new LoadingOptionsBuilder().build();
  private java.util.Map<String, Object> extensionFields_ =
      new java.util.HashMap<String, Object>();
  public LoadingOptions getLoadingOptions() {
    return this.loadingOptions_;
  }
  public java.util.Map<String, Object> getExtensionFields() {
    return this.extensionFields_;
  }

  private String class_;

  /**
   * Getter for property <I>http://commonwl.org/cwltool#CUDARequirement/class</I><BR>
   * <BLOCKQUOTE>
   * cwltool:CUDARequirement   * </BLOCKQUOTE>
   */

  public String getClass_() {
    return this.class_;
  }

  private Object cudaComputeCapability;

  /**
   * Getter for property <I>http://commonwl.org/cwltool#CUDARequirement/cudaComputeCapability</I><BR>
   * <BLOCKQUOTE>
   * CUDA hardware capability required to run the software, in X.Y
   * format.
   * 
   * * If this is a single value, it defines only the minimum
   *   compute capability.  GPUs with higher capability are also
   *   accepted.
   * 
   * * If it is an array value, then only select GPUs with compute
   *   capabilities that explicitly appear in the array.
   *    * </BLOCKQUOTE>
   */

  public Object getCudaComputeCapability() {
    return this.cudaComputeCapability;
  }

  private Object cudaDeviceCountMax;

  /**
   * Getter for property <I>http://commonwl.org/cwltool#CUDARequirement/cudaDeviceCountMax</I><BR>
   * <BLOCKQUOTE>
   * Maximum number of GPU devices to request.  If not specified,
   * same as `cudaDeviceCountMin`.
   *    * </BLOCKQUOTE>
   */

  public Object getCudaDeviceCountMax() {
    return this.cudaDeviceCountMax;
  }

  private Object cudaDeviceCountMin;

  /**
   * Getter for property <I>http://commonwl.org/cwltool#CUDARequirement/cudaDeviceCountMin</I><BR>
   * <BLOCKQUOTE>
   * Minimum number of GPU devices to request.  If not specified,
   * same as `cudaDeviceCountMax`.  If neither are specified,
   * default 1.
   *    * </BLOCKQUOTE>
   */

  public Object getCudaDeviceCountMin() {
    return this.cudaDeviceCountMin;
  }

  private String cudaVersionMin;

  /**
   * Getter for property <I>http://commonwl.org/cwltool#CUDARequirement/cudaVersionMin</I><BR>
   * <BLOCKQUOTE>
   * Minimum CUDA version to run the software, in X.Y format.  This
   * corresponds to a CUDA SDK release.  When running directly on
   * the host (not in a container) the host must have a compatible
   * CUDA SDK (matching the exact version, or, starting with CUDA
   * 11.3, matching major version).  When run in a container, the
   * container image should provide the CUDA runtime, and the host
   * driver is injected into the container.  In this case, because
   * CUDA drivers are backwards compatible, it is possible to
   * use an older SDK with a newer driver across major versions.
   * 
   * See https://docs.nvidia.com/deploy/cuda-compatibility/ for
   * details.
   *    * </BLOCKQUOTE>
   */

  public String getCudaVersionMin() {
    return this.cudaVersionMin;
  }

  /**
   * Used by {@link org.commonwl.cwlsdk.cwl1_2.utils.RootLoader} to construct instances of CUDARequirementImpl.
   *
   * @param __doc_            Document fragment to load this record object from (presumably a
                              {@link java.util.Map}).
   * @param __baseUri_        Base URI to generate child document IDs against.
   * @param __loadingOptions  Context for loading URIs and populating objects.
   * @param __docRoot_        ID at this position in the document (if available) (maybe?)
   * @throws ValidationException If the document fragment is not a {@link java.util.Map}
   *                             or validation of fields fails.
   */
  public CUDARequirementImpl(
      final Object __doc_,
      final String __baseUri_,
      LoadingOptions __loadingOptions,
      final String __docRoot_) {
    super(__doc_, __baseUri_, __loadingOptions, __docRoot_);
    // Prefix plumbing variables with '__' to reduce likelihood of collision with
    // generated names.
    String __baseUri = __baseUri_;
    String __docRoot = __docRoot_;
    if (!(__doc_ instanceof java.util.Map)) {
      throw new ValidationException("CUDARequirementImpl called on non-map");
    }
    final java.util.Map<String, Object> __doc = (java.util.Map<String, Object>) __doc_;
    final java.util.List<ValidationException> __errors =
        new java.util.ArrayList<ValidationException>();
    if (__loadingOptions != null) {
      this.loadingOptions_ = __loadingOptions;
    }
    String class_;
    try {
      class_ =
          LoaderInstances
              .uri_StringInstance_False_True_None_None
              .loadField(__doc.get("class"), __baseUri, __loadingOptions);
    } catch (ValidationException e) {
      class_ = null; // won't be used but prevents compiler from complaining.
      final String __message = "the `class` field is not valid because:";
      __errors.add(new ValidationException(__message, e));
    }
    Object cudaComputeCapability;
    try {
      cudaComputeCapability =
          LoaderInstances
              .union_of_StringInstance_or_array_of_StringInstance
              .loadField(__doc.get("cudaComputeCapability"), __baseUri, __loadingOptions);
    } catch (ValidationException e) {
      cudaComputeCapability = null; // won't be used but prevents compiler from complaining.
      final String __message = "the `cudaComputeCapability` field is not valid because:";
      __errors.add(new ValidationException(__message, e));
    }
    Object cudaDeviceCountMax;

    if (__doc.containsKey("cudaDeviceCountMax")) {
      try {
        cudaDeviceCountMax =
            LoaderInstances
                .union_of_NullInstance_or_IntegerInstance_or_ExpressionLoader
                .loadField(__doc.get("cudaDeviceCountMax"), __baseUri, __loadingOptions);
      } catch (ValidationException e) {
        cudaDeviceCountMax = null; // won't be used but prevents compiler from complaining.
        final String __message = "the `cudaDeviceCountMax` field is not valid because:";
        __errors.add(new ValidationException(__message, e));
      }

    } else {
      cudaDeviceCountMax = null;
    }
    Object cudaDeviceCountMin;

    if (__doc.containsKey("cudaDeviceCountMin")) {
      try {
        cudaDeviceCountMin =
            LoaderInstances
                .union_of_NullInstance_or_IntegerInstance_or_ExpressionLoader
                .loadField(__doc.get("cudaDeviceCountMin"), __baseUri, __loadingOptions);
      } catch (ValidationException e) {
        cudaDeviceCountMin = null; // won't be used but prevents compiler from complaining.
        final String __message = "the `cudaDeviceCountMin` field is not valid because:";
        __errors.add(new ValidationException(__message, e));
      }

    } else {
      cudaDeviceCountMin = null;
    }
    String cudaVersionMin;
    try {
      cudaVersionMin =
          LoaderInstances
              .StringInstance
              .loadField(__doc.get("cudaVersionMin"), __baseUri, __loadingOptions);
    } catch (ValidationException e) {
      cudaVersionMin = null; // won't be used but prevents compiler from complaining.
      final String __message = "the `cudaVersionMin` field is not valid because:";
      __errors.add(new ValidationException(__message, e));
    }
    if (!__errors.isEmpty()) {
      throw new ValidationException("Trying 'RecordField'", __errors);
    }
    this.class_ = (String) class_;
    this.cudaComputeCapability = (Object) cudaComputeCapability;
    this.cudaDeviceCountMax = (Object) cudaDeviceCountMax;
    this.cudaDeviceCountMin = (Object) cudaDeviceCountMin;
    this.cudaVersionMin = (String) cudaVersionMin;
    for (String field:__doc.keySet()) {
      if (!attrs.contains(field)) {
        if (field.contains(":")) {
          String expanded_field = __loadingOptions.expandUrl(field, "", false, false, null);
          extensionFields_.put(expanded_field, __doc.get(field));
        }
      }
    }
  }
  private java.util.List<String> attrs = java.util.Arrays.asList("class", "cudaComputeCapability", "cudaDeviceCountMax", "cudaDeviceCountMin", "cudaVersionMin");
}

1	// Copyright Common Workflow Language project contributors
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	package org.commonwl.cwlsdk.cwl1_2;
16
17	import org.commonwl.cwlsdk.cwl1_2.utils.LoaderInstances;
18	import org.commonwl.cwlsdk.cwl1_2.utils.LoadingOptions;
19	import org.commonwl.cwlsdk.cwl1_2.utils.LoadingOptionsBuilder;
20	import org.commonwl.cwlsdk.cwl1_2.utils.SaveableImpl;
21	import org.commonwl.cwlsdk.cwl1_2.utils.ValidationException;
22
23	/**
24	* Auto-generated class implementation for <I>http://commonwl.org/cwltool#CUDARequirement</I><BR> <BLOCKQUOTE>
25	Require support for NVIDA CUDA (GPU hardware acceleration).
26	</BLOCKQUOTE>
27	*/
28	public class CUDARequirementImpl extends SaveableImpl implements CUDARequirement {
29	private LoadingOptions loadingOptions_ = new LoadingOptionsBuilder().build();	1✔
30	private java.util.Map<String, Object> extensionFields_ =	1✔
31	new java.util.HashMap<String, Object>();
32	public LoadingOptions getLoadingOptions() {
NEW 33	return this.loadingOptions_;	×
34	}
35	public java.util.Map<String, Object> getExtensionFields() {
NEW 36	return this.extensionFields_;	×
37	}
38
39	private String class_;
40
41	/**
42	* Getter for property <I>http://commonwl.org/cwltool#CUDARequirement/class</I><BR>
43	* <BLOCKQUOTE>
44	* cwltool:CUDARequirement * </BLOCKQUOTE>
45	*/
46
47	public String getClass_() {
NEW 48	return this.class_;	×
49	}
50
51	private Object cudaComputeCapability;
52
53	/**
54	* Getter for property <I>http://commonwl.org/cwltool#CUDARequirement/cudaComputeCapability</I><BR>
55	* <BLOCKQUOTE>
56	* CUDA hardware capability required to run the software, in X.Y
57	* format.
58	*
59	* * If this is a single value, it defines only the minimum
60	* compute capability. GPUs with higher capability are also
61	* accepted.
62	*
63	* * If it is an array value, then only select GPUs with compute
64	* capabilities that explicitly appear in the array.
65	* * </BLOCKQUOTE>
66	*/
67
68	public Object getCudaComputeCapability() {
NEW 69	return this.cudaComputeCapability;	×
70	}
71
72	private Object cudaDeviceCountMax;
73
74	/**
75	* Getter for property <I>http://commonwl.org/cwltool#CUDARequirement/cudaDeviceCountMax</I><BR>
76	* <BLOCKQUOTE>
77	* Maximum number of GPU devices to request. If not specified,
78	* same as `cudaDeviceCountMin`.
79	* * </BLOCKQUOTE>
80	*/
81
82	public Object getCudaDeviceCountMax() {
NEW 83	return this.cudaDeviceCountMax;	×
84	}
85
86	private Object cudaDeviceCountMin;
87
88	/**
89	* Getter for property <I>http://commonwl.org/cwltool#CUDARequirement/cudaDeviceCountMin</I><BR>
90	* <BLOCKQUOTE>
91	* Minimum number of GPU devices to request. If not specified,
92	* same as `cudaDeviceCountMax`. If neither are specified,
93	* default 1.
94	* * </BLOCKQUOTE>
95	*/
96
97	public Object getCudaDeviceCountMin() {
NEW 98	return this.cudaDeviceCountMin;	×
99	}
100
101	private String cudaVersionMin;
102
103	/**
104	* Getter for property <I>http://commonwl.org/cwltool#CUDARequirement/cudaVersionMin</I><BR>
105	* <BLOCKQUOTE>
106	* Minimum CUDA version to run the software, in X.Y format. This
107	* corresponds to a CUDA SDK release. When running directly on
108	* the host (not in a container) the host must have a compatible
109	* CUDA SDK (matching the exact version, or, starting with CUDA
110	* 11.3, matching major version). When run in a container, the
111	* container image should provide the CUDA runtime, and the host
112	* driver is injected into the container. In this case, because
113	* CUDA drivers are backwards compatible, it is possible to
114	* use an older SDK with a newer driver across major versions.
115	*
116	* See https://docs.nvidia.com/deploy/cuda-compatibility/ for
117	* details.
118	* * </BLOCKQUOTE>
119	*/
120
121	public String getCudaVersionMin() {
NEW 122	return this.cudaVersionMin;	×
123	}
124
125	/**
126	* Used by {@link org.commonwl.cwlsdk.cwl1_2.utils.RootLoader} to construct instances of CUDARequirementImpl.
127	*
128	* @param __doc_ Document fragment to load this record object from (presumably a
129	{@link java.util.Map}).
130	* @param __baseUri_ Base URI to generate child document IDs against.
131	* @param __loadingOptions Context for loading URIs and populating objects.
132	* @param __docRoot_ ID at this position in the document (if available) (maybe?)
133	* @throws ValidationException If the document fragment is not a {@link java.util.Map}
134	* or validation of fields fails.
135	*/
136	public CUDARequirementImpl(
137	final Object __doc_,
138	final String __baseUri_,
139	LoadingOptions __loadingOptions,
140	final String __docRoot_) {
141	super(__doc_, __baseUri_, __loadingOptions, __docRoot_);	1✔
142	// Prefix plumbing variables with '__' to reduce likelihood of collision with
143	// generated names.
144	String __baseUri = __baseUri_;	1✔
145	String __docRoot = __docRoot_;	1✔
146	if (!(__doc_ instanceof java.util.Map)) {	1✔
NEW 147	throw new ValidationException("CUDARequirementImpl called on non-map");	×
148	}
149	final java.util.Map<String, Object> __doc = (java.util.Map<String, Object>) __doc_;	1✔
150	final java.util.List<ValidationException> __errors =	1✔
151	new java.util.ArrayList<ValidationException>();
152	if (__loadingOptions != null) {	1✔
153	this.loadingOptions_ = __loadingOptions;	1✔
154	}
155	String class_;
156	try {
157	class_ =	1✔
158	LoaderInstances
159	.uri_StringInstance_False_True_None_None
160	.loadField(__doc.get("class"), __baseUri, __loadingOptions);	1✔
NEW 161	} catch (ValidationException e) {	×
NEW 162	class_ = null; // won't be used but prevents compiler from complaining.	×
NEW 163	final String __message = "the `class` field is not valid because:";	×
NEW 164	__errors.add(new ValidationException(__message, e));	×
165	}	1✔
166	Object cudaComputeCapability;
167	try {
168	cudaComputeCapability =	1✔
169	LoaderInstances
170	.union_of_StringInstance_or_array_of_StringInstance
NEW 171	.loadField(__doc.get("cudaComputeCapability"), __baseUri, __loadingOptions);	×
172	} catch (ValidationException e) {	1✔
173	cudaComputeCapability = null; // won't be used but prevents compiler from complaining.	1✔
174	final String __message = "the `cudaComputeCapability` field is not valid because:";	1✔
175	__errors.add(new ValidationException(__message, e));	1✔
NEW 176	}	×
177	Object cudaDeviceCountMax;
178
179	if (__doc.containsKey("cudaDeviceCountMax")) {	1✔
180	try {
NEW 181	cudaDeviceCountMax =	×
182	LoaderInstances
183	.union_of_NullInstance_or_IntegerInstance_or_ExpressionLoader
NEW 184	.loadField(__doc.get("cudaDeviceCountMax"), __baseUri, __loadingOptions);	×
NEW 185	} catch (ValidationException e) {	×
NEW 186	cudaDeviceCountMax = null; // won't be used but prevents compiler from complaining.	×
NEW 187	final String __message = "the `cudaDeviceCountMax` field is not valid because:";	×
NEW 188	__errors.add(new ValidationException(__message, e));	×
NEW 189	}	×
190
191	} else {
192	cudaDeviceCountMax = null;	1✔
193	}
194	Object cudaDeviceCountMin;
195
196	if (__doc.containsKey("cudaDeviceCountMin")) {	1✔
197	try {
NEW 198	cudaDeviceCountMin =	×
199	LoaderInstances
200	.union_of_NullInstance_or_IntegerInstance_or_ExpressionLoader
NEW 201	.loadField(__doc.get("cudaDeviceCountMin"), __baseUri, __loadingOptions);	×
NEW 202	} catch (ValidationException e) {	×
NEW 203	cudaDeviceCountMin = null; // won't be used but prevents compiler from complaining.	×
NEW 204	final String __message = "the `cudaDeviceCountMin` field is not valid because:";	×
NEW 205	__errors.add(new ValidationException(__message, e));	×
NEW 206	}	×
207
208	} else {
209	cudaDeviceCountMin = null;	1✔
210	}
211	String cudaVersionMin;
212	try {
213	cudaVersionMin =	1✔
214	LoaderInstances
215	.StringInstance
NEW 216	.loadField(__doc.get("cudaVersionMin"), __baseUri, __loadingOptions);	×
217	} catch (ValidationException e) {	1✔
218	cudaVersionMin = null; // won't be used but prevents compiler from complaining.	1✔
219	final String __message = "the `cudaVersionMin` field is not valid because:";	1✔
220	__errors.add(new ValidationException(__message, e));	1✔
NEW 221	}	×
222	if (!__errors.isEmpty()) {	1✔
223	throw new ValidationException("Trying 'RecordField'", __errors);	1✔
224	}
NEW 225	this.class_ = (String) class_;	×
NEW 226	this.cudaComputeCapability = (Object) cudaComputeCapability;	×
NEW 227	this.cudaDeviceCountMax = (Object) cudaDeviceCountMax;	×
NEW 228	this.cudaDeviceCountMin = (Object) cudaDeviceCountMin;	×
NEW 229	this.cudaVersionMin = (String) cudaVersionMin;	×
NEW 230	for (String field:__doc.keySet()) {	×
NEW 231	if (!attrs.contains(field)) {	×
NEW 232	if (field.contains(":")) {	×
NEW 233	String expanded_field = __loadingOptions.expandUrl(field, "", false, false, null);	×
NEW 234	extensionFields_.put(expanded_field, __doc.get(field));	×
235	}
236	}
NEW 237	}	×
NEW 238	}	×
239	private java.util.List<String> attrs = java.util.Arrays.asList("class", "cudaComputeCapability", "cudaDeviceCountMax", "cudaDeviceCountMin", "cudaVersionMin");	1✔
240	}

common-workflow-language / cwljava / #423

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous