}
                if (importedClass.startsWith("java.") && isVisibleSystemClass(candidateClassName)) {
                    return candidateClassName;
                }
            } else if (name.equals(baseName)) {
                return importedClass;
            }
        }

        candidateClassName = classMetaData.getPackageName() + "." + name;

      return uid;
    }

    @Override
    public int compare(@CheckForNull Object left, @CheckForNull Object right) {
      if (left == right) {
        return 0;
      } else if (left == null) {
        return -1;
      } else if (right == null) {
        return 1;
      }
      int leftCode = identityHashCode(left);
      int rightCode = identityHashCode(right);
      if (leftCode != rightCode) {

              valueBuilder.append(tokenizer.consumeCharacter(ascii()));
            } else {
              valueBuilder.append(tokenizer.consumeToken(QUOTED_TEXT_MATCHER));
            }
          }
          value = valueBuilder.toString();
          tokenizer.consumeCharacter('"');
        } else {
          value = tokenizer.consumeToken(TOKEN_MATCHER);
        }

    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {
      throw new AssertionError("expected to throw " + expectedThrowable.getSimpleName());
    }
  }

  private enum PlatformSpecificExceptionBatch {
    PLATFORM {
      @GwtIncompatible

                this.queryAddress.isDataFromNodeStatus = true;
                addrFound = true;
                this.addressArray[ i ] = this.queryAddress;
            }
            else {
                this.addressArray[ i ] = new NbtAddress(
                    new Name(this.config, n, hexCode, scope),
                    this.queryAddress.address,
                    groupName,

        return exception;
    }

    @Override
    public String getMessage() {
        String msg = null;

        if (message != null && !message.isEmpty()) {
            msg = message;
        } else if (exception != null) {
            msg = exception.getMessage();
        }

        if (msg == null) {
            msg = "";
        }

        return msg;
    }

    @Override

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

    /**
     * Creates a new exception from the specified interim result and its associated problems.
     *

        ConcurrentHashMap<Object, Supplier<?>> cache;
        RepositoryCache repositoryCache = session.getCache();
        if (repositoryCache == null) {
            cache = new ConcurrentHashMap<>();
        } else {
            cache = (ConcurrentHashMap<Object, Supplier<?>>)
                    repositoryCache.computeIfAbsent(session, KEY, ConcurrentHashMap::new);
        }
        return new DefaultModelCache(cache);
    }

    Set<Feature<?>> features = computeMultimapAsMapGetFeatures(parentBuilder.getFeatures());
    if (Collections.disjoint(features, EnumSet.allOf(CollectionSize.class))) {
      return new TestSuite();
    } else {
      return ListTestSuiteBuilder.using(
              new MultimapAsMapGetGenerator<K, V>(parentBuilder.getSubjectGenerator()))
          .withFeatures(features)
          .named(parentBuilder.getName() + ".asMap[].get[key]")

		return e.strippedPathExpr
	}

	hasTableAlias := e.BaseKey.String() == tableAlias || strings.EqualFold(e.BaseKey.String(), baseTableName)
	var pathExpr []*JSONPathElement
	if hasTableAlias {
		pathExpr = e.PathExpr
	} else {
		pathExpr = make([]*JSONPathElement, len(e.PathExpr)+1)
		pathExpr[0] = &JSONPathElement{Key: &ObjectKey{ID: e.BaseKey}}
		copy(pathExpr[1:], e.PathExpr)
	}
	e.strippedTableAlias = tableAlias