*/
    public static String getDefaultDomain() {
        return DEFAULT_DOMAIN;
    }

    /**
     * Returns the default workstation from the current environment.
     *
     * @return A <code>String</code> containing the default workstation.
     */
    public static String getDefaultWorkstation() {
        return DEFAULT_WORKSTATION;
    }

    return sum();
  }

  /** Returns the {@link #sum} as an {@code int} after a narrowing primitive conversion. */
  @Override
  public int intValue() {
    return (int) sum();
  }

  /** Returns the {@link #sum} as a {@code float} after a widening primitive conversion. */
  @Override
  public float floatValue() {
    return (float) sum();
  }

                return (T) new DefaultVersionParser(new DefaultModelVersionParser(new GenericVersionScheme()));
            } else if (clazz == VersionRangeResolver.class) {
                return (T) new DefaultVersionRangeResolver(repositorySystem);
            } else if (clazz == ArtifactResolver.class) {
                return (T) new DefaultArtifactResolver();
            } else if (clazz == ArtifactManager.class) {

  TF_DeleteTensor(t);
  TF_DeleteStatus(status);
  return th;
}

// Return a scalar tensor handle with given values.
template <class T, TF_DataType datatype>
TFE_TensorHandle* TestScalarTensorHandle(TFE_Context* ctx, const T value) {
  T data[] = {value};
  return TestTensorHandleWithDims<T, datatype>(ctx, data, nullptr, 0);
}

// Return a tensor handle containing a 100x100 matrix of floats

            }
            return entity;
        }).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        });

        return asJson(new ApiUpdateResponse().id(fileConfig.getId()).created(true).status(Status.OK).result());
    }

            }
        }

        return itemList;
    }

    private static boolean isBugReportTarget(final Object key) {
        if ("snapshot.path".equals(key) || "label.value".equals(key)) {
            return false;
        }
        return true;
    }

    protected static Map<String, String> createPropItem(final String key) {
        return createItem(key, System.getProperty(key));
    }

    public String toString() {
        return className;
    }

    public String getClassName() {
        return className;
    }

    public String getSimpleName() {
        return StringUtils.substringAfterLast(className, ".");
    }

    public String getPackageName() {
        return packageName;
    }

    public boolean isInterface() {
        return metaType == MetaType.INTERFACE;
    }

          sum += value;
        }
        return sum / values.length;
      }
    },
    KAHAN {
      @Override
      double mean(double[] values) {
        double sum = 0.0;
        double c = 0.0;
        for (double value : values) {
          double y = value - c;
          double t = sum + y;
          c = (t - sum) - y;
          sum = t;
        }
        return sum / values.length;
      }
    },

    /**
     * 
     */
    public PreauthIntegrityNegotiateContext () {}


    /**
     * @return the salt
     */
    public byte[] getSalt () {
        return this.salt;
    }


    /**
     * @return the hashAlgos
     */
    public int[] getHashAlgos () {
        return this.hashAlgos;
    }


    /**
     * {@inheritDoc}
     *

          assertEquals(list.indexOf(key), answer);
          return;
        }
        break;
      case LAST_PRESENT:
        if (list.contains(key)) {
          assertEquals(list.lastIndexOf(key), answer);
          return;
        }
        break;
      case ANY_PRESENT:
        if (list.contains(key)) {
          assertEquals(key, list.get(answer));
          return;
        }
        break;
      case FIRST_AFTER: