return null;
        }
        try {
            return new String(data, charsetName);
        } catch (final UnsupportedEncodingException e) {
            throw new CrawlingAccessException("Unsupported encoding: " + charsetName, e);
        }
    }

    private String getResourceName(final ResponseData responseData) {
        String name = responseData.getUrl();

            assertTrue(ctx.isMICAvailable(), "MIC available when established + integrity");

            assertTrue(ctx.isSupported(mech1), "mech1 supported");
            assertTrue(ctx.isPreferredMech(mech1), "first supported is preferred");
            assertArrayEquals(new ASN1ObjectIdentifier[] { mech1, mech2 }, ctx.getSupportedMechs(), "supported mechs");

        }
        case TIME_1970_MILLIS_64BE -> enc_uint64be(date.getTime(), dst, di);
        case TIME_1970_MILLIS_64LE -> enc_uint64le(date.getTime(), dst, di);
        default -> throw new IllegalArgumentException("Unsupported time encoding");
        };
    }

    /* Decode times
     */

    /**
     * Decodes a Date value according to the specified time encoding type.
     *
     * @param src the source byte array

        case CIPHER_AES_256_CCM, CIPHER_AES_256_GCM -> 32; // AES-256 ciphers use 32-byte keys
        default -> throw new IllegalArgumentException("Unsupported cipher: " + this.cipherId);
        };
    }

    private int getAuthTagLength() {
        return 16; // All SMB3 ciphers use 16-byte authentication tags
    }

    private int getTransformFlags() {

	// Validate format version and format type.
	if formatErasure.Version != formatMetaVersionV1 {
		return fmt.Errorf("Unsupported version of backend format [%s] found on %s", formatErasure.Version, disk)
	}
	if formatErasure.Format != formatBackendErasure && formatErasure.Format != formatBackendErasureSingle {
		return fmt.Errorf("Unsupported backend format [%s] found on %s", formatErasure.Format, disk)
	}

  public void testAddAtIndex_nullUnsupported() {
    assertThrows(NullPointerException.class, () -> getList().add(0, null));
    expectUnchanged();
    expectNullMissingWhenNullUnsupported("Should not contain null after unsupported add(n, null)");
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  public void testAddAtIndex_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().add(-1, e3()));

    assertThrows(NullPointerException.class, () -> getList().addAll(0, containsNull));
    expectUnchanged();
    expectNullMissingWhenNullUnsupported(
        "Should not contain null after unsupported addAll(n, containsNull)");
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testAddAllAtIndex_middle() {
    assertTrue(

    assertThrows(NullPointerException.class, () -> collection.addAll(containsNull));
    expectUnchanged();
    expectNullMissingWhenNullUnsupported(
        "Should not contain null after unsupported addAll(containsNull)");
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_nullCollectionReference() {
    assertThrows(NullPointerException.class, () -> collection.addAll(null));
  }

    public void test_isTarget_withSupportedMimeType() {
        // Test with supported document type
        Map<String, Object> docMap = new HashMap<>();
        docMap.put("mimetype", "application/pdf");
        assertTrue(thumbnailGenerator.isTarget(docMap));
    }

    public void test_isTarget_withUnsupportedMimeType() {
        // Test with unsupported document type
        Map<String, Object> docMap = new HashMap<>();

			pbzip2.BZConcurrency((runtime.GOMAXPROCS(0)+1)/2),
			pbzip2.BZConcurrencyPool(bz2Limiter)))
	case formatLZ4:
		r = lz4.NewReader(bf)
	case formatUnknown:
		r = bf
	default:
		return fmt.Errorf("Unsupported format %s", f)
	}
	tarReader := tar.NewReader(r)
	n := 0
	asyncWriters := make(chan struct{}, 16)
	var wg sync.WaitGroup

	var asyncErr error
	var asyncErrMu sync.Mutex
	for {