!vfsHasSnapshotsAt(oldestRegisteredWatchableHierarchy)
        vfsHasSnapshotsAt(newestRegisteredWatchableHierarchy)
    }

    def "does not start watching unsupported file system for default watch mode"() {
        def unsupportedFileSystemMountPoint = file("unsupported").createDir()
        def unwatchableContent = unsupportedFileSystemMountPoint.file("file.txt").createFile()

        when:

        then:
        1 * watcherRegistry.registerWatchableHierarchy(newWatchableHierarchy, _)
    }

    def "detects unsupported file systems on default watch mode"() {
        def unsupportedFileSystems = [new File("unsupported")]

        when:
        watchingVirtualFileSystem.afterBuildStarted(WatchMode.DEFAULT, VfsLogging.NORMAL, WatchLogging.NORMAL, buildOperationRunner)
        then:

	ADDW	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"
	ADDS	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"
	ADDSW	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"
	SUB	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"

        assert output.contains("${propertyPrefix}.serviceFactoryCreate.config.autoApplied = $autoApplied")
    }

    void assertUnsupportedMessage(String output, String unsupported) {
        assert output.contains("${propertyPrefix}.checkIn.unsupported.reasonMessage = $unsupported")
    }

    void assertEndOfBuildWithFailure(String output, @Nullable String failure) {

        failure.assertHasCause(cause)

        where:
        writeCharset    | readCharset     | cause
        "'UNSUPPORTED'" | "'UTF-8'"       | "Charset for manifestContentCharset 'UNSUPPORTED' is not supported by your JVM"
        "'UTF-8'"       | "'UNSUPPORTED'" | "Charset for contentCharset 'UNSUPPORTED' is not supported by your JVM"
        null            | "'UTF-8'"       | "manifestContentCharset must not be null"

	}
	if padding == C.GO_RSA_PKCS1_OAEP_PADDING {
		md := hashToMD(h)
		if md == nil {
			return pkey, ctx, errors.New("crypto/rsa: unsupported hash function")
		}
		mgfMD := hashToMD(mgfHash)
		if mgfMD == nil {
			return pkey, ctx, errors.New("crypto/rsa: unsupported hash function")
		}
		if C._goboringcrypto_EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md) == 0 {
			return pkey, ctx, fail("EVP_PKEY_set_rsa_oaep_md")
		}

            assertContainsVersioned(AsmConstants.MAX_SUPPORTED_JAVA_VERSION, "Foo.class")
        }

        where:
        factory << [AGENT, LEGACY]
    }

    def "instrumentation for #factory removes unsupported versioned directories from multi-release jar"() {
        given:
        def testFile = jar(testDir.file("thing.jar")) {
            manifest {
                mainAttributes.putValue("Multi-Release", "true")

   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void remove(Range<K> range) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the {@code RangeMap} unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   * @since 28.1

		code:       "ParseUnsupportedToken",
		message:    "The SQL expression contains an unsupported token.",
		statusCode: 400,
		cause:      err,
	}
}

func errParseUnsupportedLiteralsGroupBy(err error) *s3Error {
	return &s3Error{
		code:       "ParseUnsupportedLiteralsGroupBy",
		message:    "The SQL expression contains an unsupported use of GROUP BY.",
		statusCode: 400,
		cause:      err,
	}
}

  /**
   * Guaranteed to throw an exception and leave the collection unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final boolean add(E e) {
    throw new UnsupportedOperationException();