function assertCharPartOffsets(actual: CharacterMapping, expected: number[][]): void {

		let charOffset = 0;
		for (let partIndex = 0; partIndex < expected.length; partIndex++) {
			let part = expected[partIndex];
			for (let i = 0; i < part.length; i++) {
				let charIndex = part[i];
				// here
				let _actualPartData = actual.charOffsetToPartData(charOffset);
				let actualPartIndex = CharacterMapping.getPartIndex(_actualPartData);
				let actualCharIndex = CharacterMapping.getCharIndex(_actualPartData);

				assert.deepEqual(
					{ partIndex: actualPartIndex, charIndex: actualCharIndex },
					{ partIndex: partIndex, charIndex: charIndex },
					`character mapping for offset ${charOffset}`
				);

				// here
				let actualOffset = actual.partDataToCharOffset(partIndex, part[part.length - 1] + 1, charIndex);

				assert.equal(
					actualOffset,
					charOffset,
					`character mapping for part ${partIndex}, ${charIndex}`
				);

				charOffset++;
			}
		}

		assert.equal(actual.length, charOffset);
	}

	function assertPartLengths(actual: CharacterMapping, expected: number[]): void {
		let _partLengths = actual.getPartLengths();
		let actualLengths: number[] = [];
		for (let i = 0; i < _partLengths.length; i++) {
			actualLengths[i] = _partLengths[i];
		}
		assert.deepEqual(actualLengths, expected, 'part lengths OK');
	}

	function assertCharacterMapping(actual: CharacterMapping, expectedCharPartOffsets: number[][], expectedPartLengths: number[]): void {

		assertCharPartOffsets(actual, expectedCharPartOffsets);

		let expectedCharAbsoluteOffset: number[] = [], currentPartAbsoluteOffset = 0;
		for (let partIndex = 0; partIndex < expectedCharPartOffsets.length; partIndex++) {
			const part = expectedCharPartOffsets[partIndex];

			for (let i = 0; i < part.length; i++) {
				const charIndex = part[i];
				expectedCharAbsoluteOffset.push(currentPartAbsoluteOffset + charIndex);
			}

			currentPartAbsoluteOffset += expectedPartLengths[partIndex];
		}

		let actualCharOffset: number[] = [];
		let tmp = actual.getAbsoluteOffsets();
		for (let i = 0; i < tmp.length; i++) {
			actualCharOffset[i] = tmp[i];
		}
		assert.deepEqual(actualCharOffset, expectedCharAbsoluteOffset);
	}