abstract Iterable<ImmutableTable<Character, Integer, String>> getTestInstances();

  public final void testClear() {
    for (Table<Character, Integer, String> testInstance : getTestInstances()) {
      assertThrows(UnsupportedOperationException.class, () -> testInstance.clear());
    }
  }

  public final void testPut() {
    for (Table<Character, Integer, String> testInstance : getTestInstances()) {

        @Override
        public String getQuery() {
            return null;
        }

        @Override
        public Map<String, String[]> getFields() {
            return null;
        }

        @Override
        public Map<String, String[]> getConditions() {
            return null;
        }

        @Override
        public String[] getLanguages() {
            return null;

        val testFileSuffix = if (descriptor.language === Language.SCALA) "Suite" else "Test"
        val sourceFile: String
        val testSourceFile: String
        val sourceFileTree: String
        val testSourceFileTree: String
        when {
            descriptor.language === Language.CPP -> {

 */
@Deprecated(since = "4.0.0")
public interface WorkspaceModelResolver {

    Model resolveRawModel(String groupId, String artifactId, String versionConstraint)
            throws UnresolvableModelException;

    Model resolveEffectiveModel(String groupId, String artifactId, String versionConstraint)
            throws UnresolvableModelException;

   * String.class}, then {@code new TypeResolver().where(formal, actual)} will {@linkplain
   * #resolveType resolve} {@code ParameterizedType List<T>} to {@code List<String>}, and resolve
   * {@code Map<T, Something>} to {@code Map<String, Something>} etc. Similarly, {@code formal} and
   * {@code actual} can be {@code Map<K, V>} and {@code Map<String, Integer>} respectively, or they

  //
  // Only one condition of a given type is allowed.
  optional string type = 1;

  // status of the condition, one of True, False, Unknown.
  // Approved, Denied, and Failed conditions may not be "False" or "Unknown".
  optional string status = 6;

  // reason indicates a brief reason for the request state
  // +optional
  optional string reason = 2;

        long endOfFile;
        long allocationSize;
        int extFileAttributes;
        int fileNameLength;
        int eaSize;
        int shortNameLength;
        String shortName;
        String filename;

        public String getName() {
            return filename;
        }
        public int getType() {
            return SmbFile.TYPE_FILESYSTEM;
        }
        public int getAttributes() {

		counter int
		mv      *MetaValue
		body    = `[
  "1st test string",
  "Roberto*Maestro", "Charles",
  0, null, false,
  1, 2.5
]`
		expected = []struct {
			Value     interface{}
			ValueType ValueType
		}{
			{
				"1st test string",
				String,
			},
			{
				"Roberto*Maestro",
				String,
			},
			{
				"Charles",
				String,
			},
			{
				0.0,
				Number,
			},
			{

  // +optional
  optional string group = 1;

  // Resource is the resource of the object being referenced.
  // +required
  optional string resource = 2;

  // Namespace is the namespace of the object being referenced.
  // +optional
  optional string namespace = 3;

  // Name is the name of the object being referenced.
  // +required
  optional string name = 4;

  val method: String? by option("-X", "--request", help = "Specify request command to use")

  val data: String? by option("-d", "--data", help = "HTTP POST data")

  val headers: List<String>? by option("-H", "--header", help = "Custom header to pass to server").multiple()