check whether this is MediaWiki 1.28 or higher but make sure getVersion
calls with readapidenied are ignored see
https://github.com/WolfgangFahl/Mediawiki-Japi/issues/32

@return
171852
public boolean isVersion128() {
    String mwversion = "Mediawiki 1.27 or before";
    try {
      mwversion = this.getVersion();
    } catch (Exception e) {
      LOGGER.log(Level.INFO,
          "Could not retrieve Mediawiki Version via API - will assume "
              + mwversion
              + " you might want to set the Version actively if you are on 1.28 and have the api blocked for non-logged in users");
    }
    boolean result = mwversion.compareToIgnoreCase("Mediawiki 1.28") >= 0;
    return result;
  }
677760
public byte getGuaranteedProtocolVersion() {
    Byte value = (Byte)jmo.getField(ControlAccess.PROTOCOLVERSION);
    return (value == null) ? 0 : value.byteValue();
  }
50841
private Version findHighestMutualVersion(Versions offeredVersions) {
		Version highestSupportedVersion = null;

		for (String supportedVersion : Arrays.asList(AppConfig.SUPPORTED_VERSIONS)) {

			Version match = offeredVersions.find(supportedVersion);
			if (match != null) {
				highestSupportedVersion = match;
			}
		}
		return highestSupportedVersion;
	}
1273955
@Override
	public VersionInfo version() {
		return credHubOperations.doWithRest(restOperations -> {
			ResponseEntity<VersionInfo> response = restOperations
					.getForEntity(VERSION_URL_PATH, VersionInfo.class);

			ExceptionUtils.throwExceptionOnError(response);

			return response.getBody();
		});
	}
1261691
public int ENgetversion() throws EpanetException {
        int[] version = new int[0];
        int errcode = epanet.ENgetversion(version);
        checkError(errcode);
        return version[0];
    }
267069
private boolean isCorrectVersion(ApplicationInfo app) {
    for (String key : keysToConsiderInThePlistToHaveEquality) {
      Object value = app.getProperty(key);
      Object exp = ipa.getMetadata().opt(key);
      if (value instanceof String) {
        if (!value.equals(exp)) {
          log.fine("for key " + key + ",device has" + value + ",but needed " + exp
                   + ".the app will need to be reinstalled.");
          return false;
        }
      }
    }
    return true;
  }
762481
protected String getVersionFromServer() throws IOException {
		URL url = new URL(VERSION_CHECK_URL);
		InputStream is = url.openStream();
		try {
			byte[] buff = new byte[4048];
			int len = is.read(buff);
			return new String(buff, 0, len);
		} finally {
			is.close();
		}
	}
1338578
public int getVersion() {
        if (info == null)
            return -1;
        try {
            int vers = ((Integer)info.get(CertificateVersion.NAME
                        + DOT + CertificateVersion.VERSION)).intValue();
            return vers+1;
        } catch (Exception e) {
            return -1;
        }
    }
235830
protected final long parseVersionAndFlags(ByteBuffer content) {
        version = IsoTypeReader.readUInt8(content);
        flags = IsoTypeReader.readUInt24(content);
        return 4;
    }
1251058
public boolean isUpdateForVersionName() {
		Set<String> uniques = new HashSet<String>();
		for (VersionHistoryItem item : versionHistoryItems) {
			uniques.add(item.getVersionName());
		}
		return uniques.size() > 1;
	}
937949
public static int getAppVersion(@NonNull Context context) {
        try {
            return context.getPackageManager()
                    .getPackageInfo(context.getPackageName(), 0).versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            return -1;
        }
    }
224644
public int getUserVersion() {
		int userVersion = -1;
		Integer userVersionObject = querySingleTypedResult(
				"PRAGMA user_version", null, GeoPackageDataType.MEDIUMINT);
		if (userVersionObject != null) {
			userVersion = userVersionObject;
		}
		return userVersion;
	}
1166873
private boolean versionCheck(String title) {
        if (this.type != UpdateType.NO_VERSION_CHECK) {
            final String version = caller.getPluginVersion();
            final String remoteVersion = title; // Get the newest file's version number

            if (this.hasTag(version) || version.contains(remoteVersion)) {
                // We already have the latest version, or this build is tagged for no-update
                this.result = Updater.UpdateResult.NO_UPDATE;
                return false;
            }
        }
        return true;
    }
202359
public static boolean isVersionPre12(Configuration cfg) {
      String version = cfg.version().toString();
      return Objects.equals(version, "1.0") || Objects.equals(version, "1.1");
   }
435097
@Override
    public VersionInfo getUCAVersion() {
        VersionInfo v = getVersion();
        // Note: This is tied to how the current implementation encodes the UCA version
        // in the overall getVersion().
        // Alternatively, we could load the root collator and get at lower-level data from there.
        // Either way, it will reflect the input collator's UCA version only
        // if it is a known implementation.
        // (C++ comment) It would be cleaner to make this a virtual Collator method.
        // (In Java, it is virtual.)
        return VersionInfo.getInstance(v.getMinor() >> 3, v.getMinor() & 7, v.getMilli() >> 6, 0);
    }
1317355
@FFDCIgnore(NumberFormatException.class)
    private static boolean determineIsJava8Before161(String version) {
        try {
            return version != null 
                && version.startsWith("1.8.0_")
                && Integer.parseInt(version.substring(6)) < 161;
        } catch (NumberFormatException ex) {
            //no-op
        }
        return false;
    }
1050909
public static void verifyVersion(int reportedVersion,
      int expectedVersion, String annotation) throws IOException {
    if ((reportedVersion ^ expectedVersion) < 0) {
      throw new IOException("reportedVersion and expectedVersion have" +
          " different signs : " + reportedVersion + ", " + expectedVersion);
    }
    // layout_version is negative and data_transfer is positive, so we need to
    // look at the absolute.
    if (Math.abs(reportedVersion) < Math.abs(expectedVersion))
      throw new IncorrectVersionException(
          reportedVersion, "data node " + annotation, expectedVersion);
  }