if (jdk.startsWith("!")) {
            reverse = true;
            jdk = jdk.substring(1);
        }

        if (getJdkVersion().startsWith(jdk)) {
            return !reverse;
        } else {
            return reverse;
        }
    }

    private boolean matchJdkVersionRange(String jdk) throws InvalidVersionSpecificationException {

    assertEqualInOrder(values, multimap().get(key));

    if (!values.isEmpty()) {
      assertEqualInOrder(values, multimap().asMap().get(key));
      assertFalse(multimap().isEmpty());
    } else {
      assertNull(multimap().asMap().get(key));
    }

    assertEquals(values.size(), multimap().get(key).size());
    assertEquals(values.size() > 0, multimap().containsKey(key));

          Object instance = tester.instantiate(classToTest);
          if (instance != null) {
            if (isEqualsDefined(classToTest)) {
              SerializableTester.reserializeAndAssert(instance);
            } else {
              SerializableTester.reserialize(instance);
            }
          }
        } catch (Throwable e) {
          throw sanityError(classToTest, SERIALIZABLE_TEST_METHOD_NAMES, "serializable test", e);

			t.Errorf("Test %d: Decryption returned wrong error code: got %d , want %d", i, err, test.expErr)
		} else if _, enc := crypto.IsEncrypted(test.info.UserDefined); encrypted && enc != encrypted {
			t.Errorf("Test %d: Decryption thinks object is encrypted but it is not", i)
		} else if !encrypted && enc != encrypted {
			t.Errorf("Test %d: Decryption thinks object is not encrypted but it is", i)
		}
	}
}

            if ((newState & Smb2LeaseState.SMB2_LEASE_READ_CACHING) == 0) {
                // Lost read cache - invalidate directory cache
                entry.invalidate();
            }
        } else {
            // Lease completely broken - invalidate cache
            entry.invalidate();
        }

        if ((newState & Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING) == 0) {

        assertArgumentNotNull("handler", handler);

        if (jarFile.getName().toLowerCase().endsWith(WAR_FILE_EXTENSION)) {
            forEach(jarFile, WEB_INF_CLASSES_PATH, handler);
        } else {
            forEach(jarFile, "", handler);
        }
    }

    /**
     * Traverses classes contained in a Jar file.
     * <p>

                                if (last == null) {
                                    logger.debug("", throwable);
                                } else {
                                    logger.debug(String.valueOf(last), throwable);
                                }
                            } else {
                                if (last != null) {
                                    logger.debug(String.valueOf(last));

                }
                filePrefix = buf.toString();
                extension = strings[strings.length - 1];
            } else {
                filePrefix = name;
                extension = "";
            }
        } else {
            filePrefix = "none";
            extension = "";
        }
        File inputFile = null;
        File outputFile = null;
        try {

          null
        }

      return when {
        extensions != null -> AndroidCertificateChainCleaner(trustManager, extensions)
        else -> null
      }
    }
  }

          activeLogger.addHandler(handler)
          activeLogger.level = Level.ALL

          getLogger("jdk.event.security").level = Level.INFO
          getLogger("org.conscrypt").level = Level.INFO
        } else {
          if (showHttp2Frames) {
            val activeLogger = getLogger(Http2::class.java.name)
            activeLogger.level = Level.FINE
            handler.level = Level.FINE