if (token instanceof TestAnalyzeToken) {
                    TestAnalyzeToken testToken = (TestAnalyzeToken) token;
                    if (japaneseMode && "ja".equals(lang)) {
                        // Simulate Japanese reading conversion
                        testToken.setReading(convertToJapaneseReading(testToken.getTerm()));
                    } else {
                        // Default: uppercase for reading

        int securityBufferOffset = SMBUtil.readInt2(buffer, bodyOffset + 12);
        byte[] actualToken = new byte[TEST_TOKEN.length];
        System.arraycopy(buffer, headerStart + securityBufferOffset, actualToken, 0, TEST_TOKEN.length);
        assertArrayEquals(TEST_TOKEN, actualToken);
    }

    @Test
    @DisplayName("Should write correct bytes to wire format without session binding")

        setupEpg(_epgMap, et -> ((AccessToken) et).getPermissions(), (et, vl) -> ((AccessToken) et).setPermissions((String[]) vl),
                "permissions");
        setupEpg(_epgMap, et -> ((AccessToken) et).getToken(), (et, vl) -> ((AccessToken) et).setToken(DfTypeUtil.toString(vl)), "token");
        setupEpg(_epgMap, et -> ((AccessToken) et).getUpdatedBy(), (et, vl) -> ((AccessToken) et).setUpdatedBy(DfTypeUtil.toString(vl)),
                "updatedBy");

                finalOffset = correctOffset(blkStart + nextToken.endOffset);
                offsetAttr.setOffset(correctOffset(blkStart + nextToken.startOffset), finalOffset);
                posIncAttr.setPositionIncrement(nextToken.posInc);
                return true;
            }
        }
    }

    static MyToken getNextUniqueToken(final PriorityQueue<MyToken> que, final MyToken prev) {

        try (final JsonParser jsonParser = jsonFactory.createJsonParser(jwtClaim)) {
            while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
                final String name = jsonParser.getCurrentName();
                if (name != null) {
                    jsonParser.nextToken();

                    if (jsonParser.getCurrentToken() == JsonToken.START_ARRAY) {
                        // Handle array type

                            tokenizer.nextToken(INDEXED_END));
                    break;
                case MAPPED_START:
                    value = getMappedValue(
                            expression,
                            propertyPosition,
                            tokenizer.getPosition(),
                            value,
                            tokenizer.nextToken(MAPPED_END));
                    break;

        final StringTokenizer st = new StringTokenizer(textual, "-");
        if (st.countTokens() < 3 || !st.nextToken().equals("S")) {
            // need S-N-M
            throw new SmbException("Bad textual SID format: " + textual);
        }

        this.revision = Byte.parseByte(st.nextToken());
        final String tmp = st.nextToken();
        long id = 0;
        if (tmp.startsWith("0x")) {

    }

    private static SpnegoToken getToken(final byte[] token, final int off, final int len) throws SpnegoException {
        byte[] b = new byte[len];
        if (off == 0 && token.length == len) {
            b = token;
        } else {
            System.arraycopy(token, off, b, 0, len);
        }
        return getToken(b);
    }

    private static SpnegoToken getToken(final byte[] token) throws SpnegoException {

				Name:    objName,
				Size:    int64(file.UncompressedSize64),
				ModTime: zipObjInfo.ModTime,
			})
			count++
		}
	next:
		nextToken = objName
	}

	if isTruncated {
		listObjectsInfo.IsTruncated = true
		listObjectsInfo.NextContinuationToken = nextToken
	}

	return listObjectsInfo, nil
}

// getFilesFromZIPObject reads a partial stream of a zip file to build the zipindex.Files index

			buf.Write(blk[:])
			for _, c := range blk {
				if c == '\n' {
					cntNewline++
				}
			}
		}
		return nil
	}

	// nextToken gets the next token delimited by a newline. This assumes that
	// at least one newline exists in the buffer.
	nextToken := func() string {
		cntNewline--
		tok, _ := buf.ReadString('\n')
		return strings.TrimRight(tok, "\n")
	}

	// Parse for the number of entries.