/*******************************************************************************
 * Copyright (c) 2000, 2020 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jface.text.tests;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.NoSuchElementException;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GlyphMetrics;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.TextPresentation;

public class TextPresentationTest {

	private static final int NORMAL= SWT.NORMAL;
	private static final int BOLD= SWT.BOLD;

	private TextPresentation fTextPresentation;
	private StyleRange[] fAllRanges;
	private StyleRange[] fNonDefaultRanges;

	// collect colors for disposal
	private ArrayList<Color> fColors= new ArrayList<>();

	private Display fDisplay;

	@Before
	public void setUp() {
		fDisplay= Display.getDefault();
		setUpStyleRanges();
		setUpTextPresentation();
	}

	private void setUpStyleRanges() {
		fAllRanges= new StyleRange[] {
			createStyleRange(  0,   4, NORMAL),
			createStyleRange(  4,  20, BOLD),
			createStyleRange( 20,  47, NORMAL),
			createStyleRange( 47,  54, BOLD),
			createStyleRange( 54,  96, NORMAL),
			createStyleRange( 96, 102, BOLD),
			createStyleRange(102, 140, NORMAL)
		};

		fNonDefaultRanges= new StyleRange[] {
			createStyleRange(  4,  20, BOLD),
			createStyleRange( 47,  54, BOLD),
			createStyleRange( 96, 102, BOLD)
		};
	}

	private void setUpTextPresentation() {
		fTextPresentation= new TextPresentation();
		fTextPresentation.setDefaultStyleRange(createStyleRange(0, 140, NORMAL));
		for (StyleRange range : fAllRanges) {
			fTextPresentation.addStyleRange(range);
		}
	}

	@After
	public void tearDown() {
		fColors.clear();
		fDisplay.dispose();
	}

	private StyleRange createStyleRange(int start, int end, int style) {
		return createStyleRange(start, end, style, null, null);
	}

	private StyleRange createStyleRange(int start, int end, int style, Color foreground, Color background) {
		return new StyleRange(start, end - start, foreground, background, style);
	}

	private StyleRange createStyleRange(int start, int end, int style, int foreground, int background) {
		return createStyleRange(start, end, style, createColor(foreground, foreground, foreground), createColor(background, background, background));
	}

	/**
	 * Creates a new color.
	 *
	 * @param red the amount of red in the color
	 * @param green the amount of green in the color
	 * @param blue the amount of blue in the color
	 * @return <code>null</code> if any of the parameters is smaller than 0 or greater than 255
	 */
	private Color createColor(int red, int green, int blue) {
		if (red < 0 || red > 255 || green < 0 || green > 255 || blue < 0 || blue > 255)
			return null;
		Color c= new Color(fDisplay, red, green, blue);
		fColors.add(c);
		return c;
	}

	/**
	 * Check that the presentation contains the expected style ranges and other presentation methods
	 * return compatible values.
	 *
	 * @param expectedAllRanges all styles expected for the whole presentation
	 * @param expectedNonDefaultRanges all styles which are not the default for the whole
	 *            presentation
	 */
	protected void checkRegions(StyleRange[] expectedAllRanges, StyleRange[] expectedNonDefaultRanges) {
		checkRegions(expectedAllRanges, fTextPresentation.getAllStyleRangeIterator(), true);
		checkRegions(expectedNonDefaultRanges, fTextPresentation.getNonDefaultStyleRangeIterator(), false);
		// now test the same but remove the default style
		StyleRange defaultRange= fTextPresentation.getDefaultStyleRange();
		fTextPresentation.setDefaultStyleRange(null);
		checkRegions(expectedAllRanges, fTextPresentation.getAllStyleRangeIterator(), true);
		checkRegions(expectedAllRanges, fTextPresentation.getNonDefaultStyleRangeIterator(), true);
		fTextPresentation.setDefaultStyleRange(defaultRange);
	}

	/**
	 * Check expected regions against existing regions from presentation. Also validates that
	 * iterator returns ordered and disjoint styles and most other presentation methods.
	 *
	 * @param expectedRanges the expected regions
	 * @param rangeIterator iterator from presentation to get the actual regions
	 * @param withDefaults if <code>true</code> the expected ranges also contains the ranges which
	 *            are equal to default style
	 */
	private void checkRegions(StyleRange[] expectedRanges, Iterator<StyleRange> rangeIterator, boolean withDefaults) {
		StyleRange defaultRange= fTextPresentation.getDefaultStyleRange();
		int start= -1, end= -1;
		int lastEnd= defaultRange != null ? defaultRange.start : Integer.MIN_VALUE;
		for (int i= 0; i < expectedRanges.length; i++) {
			StyleRange expectedRange= expectedRanges[i];
			assertTrue("Presentation has less ranges than expected.", rangeIterator.hasNext());
			StyleRange actualRange= rangeIterator.next();
			assertEquals(expectedRange, actualRange);
			assertTrue("Unexpected default style.", withDefaults || !actualRange.similarTo(defaultRange));
			assertTrue("Overlapping or wrong ordered style.", lastEnd <= actualRange.start);
			lastEnd= actualRange.start + actualRange.length;

			// test first and last range methods
			if (i == 0) {
				start= actualRange.start;
				StyleRange first= fTextPresentation.getFirstStyleRange();
				if (withDefaults) {
					assertEquals("getFirstStyleRange() failed", expectedRange, first);
				} else {
					assertTrue("getFirstStyleRange() failed", first.equals(expectedRange) || first.similarTo(defaultRange));
				}
			} else if (i == expectedRanges.length - 1) {
				end= actualRange.start + actualRange.length;
				StyleRange last= fTextPresentation.getLastStyleRange();
				if (withDefaults) {
					assertEquals("getLastStyleRange() failed", expectedRange, last);
				} else {
					assertTrue("getLastStyleRange() failed", last.equals(expectedRange) || last.similarTo(defaultRange));
				}
			}
		}
		assertTrue("Presentation has more ranges than expected.", !rangeIterator.hasNext());
		if (withDefaults) {
			assertEquals("getDenumerableRanges() failed", expectedRanges.length, fTextPresentation.getDenumerableRanges());
		}
		assertEquals("isEmpty() failed", Boolean.valueOf(expectedRanges.length == 0 && defaultRange == null), Boolean.valueOf(fTextPresentation.isEmpty()));
		IRegion expectedCover;
		if (defaultRange == null) {
			expectedCover= (start == -1 && end == -1 ? null : new Region(start, end - start));
		} else {
			expectedCover= new Region(defaultRange.start, defaultRange.length);
		}
		assertEquals("Wrong coverage", expectedCover, fTextPresentation.getCoverage());
	}

	@Test
	public void testUnclippedRegions() {
		checkRegions(fAllRanges, fNonDefaultRanges);
	}

	@Test
	public void testClippedRegions1() {
		fTextPresentation.setResultWindow(new Region(0, 140));
		checkRegions(fAllRanges, fNonDefaultRanges);
	}

	@Test
	public void testClippedRegions2() {

		fTextPresentation.setResultWindow(new Region(30, 70));

		StyleRange[] expectedAllRanges= new StyleRange[] {
			createStyleRange(  0, 17, NORMAL),
			createStyleRange( 17, 24, BOLD),
			createStyleRange( 24, 66, NORMAL),
			createStyleRange( 66, 70, BOLD)
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
			createStyleRange( 17, 24, BOLD),
			createStyleRange( 66, 70, BOLD)
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range at start of first existing range.
	 */
	@Test
	public void testMergeStyleRange1() {
		StyleRange range= createStyleRange(0, 2, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   2, NORMAL, 1, -1),
				createStyleRange(  2,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  0,   2, NORMAL, 1, -1),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range at end of last existing range.
	 */
	@Test
	public void testMergeStyleRange2() {
		StyleRange range= createStyleRange(138, 140, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 138, NORMAL),
				createStyleRange(138, 140, NORMAL, 1, -1),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(138, 140, NORMAL, 1, -1),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range at start of existing default range.
	 */
	@Test
	public void testMergeStyleRange3() {
		StyleRange range= createStyleRange(20, 22, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  22, NORMAL, 1, -1),
				createStyleRange( 22,  47, NORMAL),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  22, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range within existing default range.
	 */
	@Test
	public void testMergeStyleRange4() {
		StyleRange range= createStyleRange(22, 24, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  22, NORMAL),
				createStyleRange( 22,  24, NORMAL, 1, -1),
				createStyleRange( 24,  47, NORMAL),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 22,  24, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range at end of existing default range.
	 */
	@Test
	public void testMergeStyleRange5() {
		StyleRange range= createStyleRange(45, 47, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  45, NORMAL),
				createStyleRange( 45,  47, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 45,  47, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range at start of existing non-default range.
	 */
	@Test
	public void testMergeStyleRange6() {
		StyleRange range= createStyleRange(47, 49, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL),
				createStyleRange( 47,  49, BOLD, 1, -1),
				createStyleRange( 49,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 47,  49, BOLD, 1, -1),
				createStyleRange( 49,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range within existing non-default range.
	 */
	@Test
	public void testMergeStyleRange7() {
		StyleRange range= createStyleRange(49, 51, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL),
				createStyleRange( 47,  49, BOLD),
				createStyleRange( 49,  51, BOLD, 1, -1),
				createStyleRange( 51,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 47,  49, BOLD),
				createStyleRange( 49,  51, BOLD, 1, -1),
				createStyleRange( 51,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range at end of existing non-default range.
	 */
	@Test
	public void testMergeStyleRange8() {
		StyleRange range= createStyleRange(52, 54, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL),
				createStyleRange( 47,  52, BOLD),
				createStyleRange( 52,  54, BOLD, 1, -1),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 47,  52, BOLD),
				createStyleRange( 52,  54, BOLD, 1, -1),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range from existing default to non-default range.
	 */
	@Test
	public void testMergeStyleRange9() {
		StyleRange range= createStyleRange(45, 49, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  45, NORMAL),
				createStyleRange( 45,  47, NORMAL, 1, -1),
				createStyleRange( 47,  49, BOLD,   1, -1),
				createStyleRange( 49,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 45,  47, NORMAL, 1, -1),
				createStyleRange( 47,  49, BOLD,   1, -1),
				createStyleRange( 49,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range from existing non-default to default range.
	 */
	@Test
	public void testMergeStyleRange10() {
		StyleRange range= createStyleRange(52, 56, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL),
				createStyleRange( 47,  52, BOLD),
				createStyleRange( 52,  54, BOLD,   1, -1),
				createStyleRange( 54,  56, NORMAL, 1, -1),
				createStyleRange( 56,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 47,  52, BOLD),
				createStyleRange( 52,  54, BOLD,   1, -1),
				createStyleRange( 54,  56, NORMAL, 1, -1),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range from existing default over non-default to default range.
	 */
	@Test
	public void testMergeStyleRange11() {
		StyleRange range= createStyleRange(45, 56, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  45, NORMAL),
				createStyleRange( 45,  47, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD,   1, -1),
				createStyleRange( 54,  56, NORMAL, 1, -1),
				createStyleRange( 56,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 45,  47, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD,   1, -1),
				createStyleRange( 54,  56, NORMAL, 1, -1),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range from existing non-default over default to non-default range.
	 */
	@Test
	public void testMergeStyleRange12() {
		StyleRange range= createStyleRange(52, 98, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL),
				createStyleRange( 47,  52, BOLD),
				createStyleRange( 52,  54, BOLD,   1, -1),
				createStyleRange( 54,  96, NORMAL, 1, -1),
				createStyleRange( 96,  98, BOLD,   1, -1),
				createStyleRange( 98, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 47,  52, BOLD),
				createStyleRange( 52,  54, BOLD,   1, -1),
				createStyleRange( 54,  96, NORMAL, 1, -1),
				createStyleRange( 96,  98, BOLD,   1, -1),
				createStyleRange( 98, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range over existing default range.
	 */
	@Test
	public void testMergeStyleRange13() {
		StyleRange range= createStyleRange(20, 47, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range over existing non-default range.
	 */
	@Test
	public void testMergeStyleRange14() {
		StyleRange range= createStyleRange(47, 54, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL),
				createStyleRange( 47,  54, BOLD, 1, -1),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 47,  54, BOLD, 1, -1),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range over whole presentation.
	 */
	@Test
	public void testMergeStyleRange15() {
		StyleRange range= createStyleRange(0, 140, NORMAL, 1, -1);

		Color expectedColor= createColor(1, 1, 1);
		StyleRange[] expectedAllRanges= new StyleRange[fAllRanges.length];
		for (int i= 0; i < fAllRanges.length; i++) {
			expectedAllRanges[i]= (StyleRange) fAllRanges[i].clone();
			expectedAllRanges[i].foreground= expectedColor;
		}

		StyleRange[] expectedNonDefaultRanges= expectedAllRanges;

		fTextPresentation.mergeStyleRange(range);
		checkRegions(expectedAllRanges, expectedNonDefaultRanges);


		range= createStyleRange(-100, 200, BOLD);

		for (int i= 0; i < expectedAllRanges.length; i++) {
			expectedAllRanges[i].fontStyle= BOLD;
		}

		fTextPresentation.mergeStyleRange(range);
		checkRegions(expectedAllRanges, expectedNonDefaultRanges);

		fTextPresentation.setDefaultStyleRange(null);
		range= createStyleRange(-150, 250, NORMAL, -1, 2);

		expectedColor= createColor(2, 2, 2);
		for (int i= 0; i < expectedAllRanges.length; i++) {
			expectedAllRanges[i].background= expectedColor;
		}
		StyleRange[] newExpectedRanges= new StyleRange[expectedAllRanges.length + 2];
		System.arraycopy(expectedAllRanges, 0, newExpectedRanges, 1, expectedAllRanges.length);
		newExpectedRanges[0]= createStyleRange(-150, 0, NORMAL, -1, 2);
		newExpectedRanges[newExpectedRanges.length - 1]= createStyleRange(140, 250, NORMAL, -1, 2);

		fTextPresentation.mergeStyleRange(range);
		checkRegions(newExpectedRanges, newExpectedRanges);
	}

	/**
	 * Merge range covering existing default range.
	 */
	@Test
	public void testMergeStyleRange16() {
		StyleRange range= createStyleRange(20, 47, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range covering existing non-default range.
	 */
	@Test
	public void testMergeStyleRange17() {
		StyleRange range= createStyleRange(47, 54, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL),
				createStyleRange( 47,  54, BOLD, 1, -1),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 47,  54, BOLD, 1, -1),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range covering three ranges.
	 */
	@Test
	public void testMergeStyleRange18() {
		StyleRange range= createStyleRange(20, 96, NORMAL, 1, -1);
		fTextPresentation.mergeStyleRange(range);

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD,   1, -1),
				createStyleRange( 54,  96, NORMAL, 1, -1),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL, 1, -1),
				createStyleRange( 47,  54, BOLD,   1, -1),
				createStyleRange( 54,  96, NORMAL, 1, -1),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range starting and ending outside.
	 */
	@Test
	public void testMergeStyleRange22() {
		StyleRange range= createStyleRange(-5, 145, BOLD, 1, -1);

		Color expectedColor= createColor(1, 1, 1);
		StyleRange[] expectedAllRanges= new StyleRange[fAllRanges.length];
		for (int i= 0; i < fAllRanges.length; i++) {
			expectedAllRanges[i]= (StyleRange) fAllRanges[i].clone();
			expectedAllRanges[i].fontStyle= BOLD;
			expectedAllRanges[i].foreground= expectedColor;
		}
		StyleRange[] expectedNonDefaultRanges= expectedAllRanges;

		fTextPresentation.mergeStyleRange(range);
		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge range starting and ending outside without default style.
	 */
	@Test
	public void testMergeStyleRange23() {
		fTextPresentation.setDefaultStyleRange(null);
		StyleRange range= createStyleRange(-5, 145, BOLD, 1, -1);

		Color expectedColor= createColor(1, 1, 1);
		StyleRange[] expectedAllRanges= new StyleRange[fAllRanges.length + 2];
		expectedAllRanges[0]= createStyleRange(-5, 0, BOLD, 1, -1);
		for (int i= 0; i < fAllRanges.length; i++) {
			expectedAllRanges[i + 1]= (StyleRange) fAllRanges[i].clone();
			expectedAllRanges[i + 1].fontStyle= BOLD;
			expectedAllRanges[i + 1].foreground= expectedColor;
		}
		expectedAllRanges[expectedAllRanges.length - 1]= createStyleRange(140, 145, BOLD, 1, -1);

		StyleRange[] expectedNonDefaultRanges= expectedAllRanges;

		fTextPresentation.mergeStyleRange(range);
		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Merge/replace styles on default only presentation.
	 */
	@Test
	public void testApplyStyleRange1() {
		fTextPresentation.clear();
		fTextPresentation.setDefaultStyleRange(createStyleRange(0, 140, NORMAL));
		for (StyleRange range : deepClone(fAllRanges)) {
			fTextPresentation.mergeStyleRange(range);
		}
		checkRegions(fAllRanges, fNonDefaultRanges);

		fTextPresentation.clear();
		fTextPresentation.setDefaultStyleRange(createStyleRange(0, 140, NORMAL));
		for (StyleRange range : deepClone(fAllRanges)) {
			fTextPresentation.replaceStyleRange(range);
		}
		checkRegions(fAllRanges, fNonDefaultRanges);
	}

	/**
	 * Merge/replace styles without default on empty presentation.
	 */
	@Test
	public void testApplyStyleRange2() {
		fTextPresentation.clear();
		for (StyleRange range : deepClone(fAllRanges)) {
			fTextPresentation.mergeStyleRange(range);
		}
		checkRegions(fAllRanges, fAllRanges);

		fTextPresentation.clear();
		for (StyleRange range : deepClone(fAllRanges)) {
			fTextPresentation.replaceStyleRange(range);
		}
		checkRegions(fAllRanges, fAllRanges);
	}

	/**
	 * Merge/replace styles without default on existing styles.
	 */
	@Test
	public void testApplyStyleRange3() {
		fTextPresentation.clear();
		fTextPresentation.mergeStyleRange(createStyleRange(0, 140, NORMAL));
		for (StyleRange range : deepClone(fAllRanges)) {
			fTextPresentation.mergeStyleRange(range);
		}
		checkRegions(fAllRanges, fAllRanges);

		fTextPresentation.clear();
		fTextPresentation.mergeStyleRange(createStyleRange(0, 140, NORMAL));
		for (StyleRange range : deepClone(fAllRanges)) {
			fTextPresentation.replaceStyleRange(range);
		}
		checkRegions(fAllRanges, fAllRanges);
	}

	/**
	 * Merge/replace empty range.
	 */
	@Test
	public void testApplyStyleRange4() {
		StyleRange empty= createStyleRange(0, 0, BOLD);
		fTextPresentation.mergeStyleRange(empty);
		checkRegions(fAllRanges, fNonDefaultRanges);
		fTextPresentation.replaceStyleRange(empty);
		checkRegions(fAllRanges, fNonDefaultRanges);
	}

	/**
	 * Test merge operation involving link styling.
	 */
	@Test
	public void testLinkMerge() {
		Color linkColor= createColor(0, 0, 255);
		StyleRange[] ranges= new StyleRange[] {
				createStyleRange(  4,  20, NORMAL),        // default underline
				createStyleRange( 20,  47, NORMAL),        // explicit default underline
				createStyleRange( 47,  54, NORMAL),        // double underline
				createStyleRange( 96, 102, NORMAL, 1, -1), // set color for later test
				createStyleRange(102, 140, NORMAL),        // link
		};

		ranges[0].underline= true;

		ranges[1].underline= true;
		ranges[1].underlineStyle= SWT.UNDERLINE_SINGLE;

		ranges[2].underline= true;
		ranges[2].underlineStyle= SWT.UNDERLINE_DOUBLE;

		ranges[4].underline= true;
		ranges[4].underlineStyle= SWT.UNDERLINE_LINK;
		ranges[4].foreground= linkColor;

		for (StyleRange range : deepClone(ranges)) {
			fTextPresentation.mergeStyleRange(range);
		}

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  47, NORMAL),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD, 1, -1),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				expectedAllRanges[1],
				expectedAllRanges[2],
				expectedAllRanges[3],
				expectedAllRanges[5],
				expectedAllRanges[6],
		};

		expectedNonDefaultRanges[0].underline= true;

		expectedNonDefaultRanges[1].underline= true;
		expectedNonDefaultRanges[1].underlineStyle= SWT.UNDERLINE_SINGLE;

		expectedNonDefaultRanges[2].underline= true;
		expectedNonDefaultRanges[2].underlineStyle= SWT.UNDERLINE_DOUBLE;

		expectedNonDefaultRanges[4].underline= true;
		expectedNonDefaultRanges[4].underlineStyle= SWT.UNDERLINE_LINK;
		expectedNonDefaultRanges[4].foreground= linkColor;

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);


		for (int i= 0; i < 3; i++) {
			ranges[i].underlineStyle= SWT.UNDERLINE_LINK;
			ranges[i].foreground= linkColor;
			expectedNonDefaultRanges[i].underlineStyle= SWT.UNDERLINE_LINK;
			expectedNonDefaultRanges[i].foreground= linkColor;
		}

		ranges[3].underlineStyle= SWT.UNDERLINE_LINK;
		ranges[3].foreground= null;
		expectedNonDefaultRanges[3].underlineStyle= SWT.UNDERLINE_LINK;
		expectedNonDefaultRanges[3].foreground= null; // merging underline_link force set the foreground

		ranges[4].underlineStyle= SWT.UNDERLINE_SQUIGGLE;
		// expect no change for expectedNonDefaultRanges[4]. underline_link cannot removed using merge

		for (StyleRange range : ranges) {
			fTextPresentation.mergeStyleRange(range);
		}
		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Test merge operation with all style parts.
	 */
	@Test
	public void testMergeAll() {
		StyleRange range= createStyleRange(4, 20, BOLD, 1, 2);
		range.borderColor= createColor(3, 3, 3);
		range.borderStyle= SWT.BORDER_DASH;
		range.font= fDisplay.getSystemFont();
		range.metrics= new GlyphMetrics(0, 0, 10);
		range.strikeout= true;
		range.strikeoutColor= createColor(4, 4, 4);
		range.underline= true;
		range.underlineColor= createColor(5, 5, 5);
		range.underlineStyle= SWT.UNDERLINE_SQUIGGLE;
		fTextPresentation.mergeStyleRange((StyleRange) range.clone());

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   4, NORMAL),
				(StyleRange) range.clone(),
				createStyleRange( 20,  47, NORMAL),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 140, NORMAL),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				(StyleRange) range.clone(),
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);

		range.background= null;
		range.borderColor= null;
		range.borderStyle= SWT.NONE;
		range.font= null;
		range.fontStyle= SWT.NORMAL;
		range.foreground= null;
		range.metrics= null;
		range.strikeout= false;
		range.strikeoutColor= null;
		range.underline= false;
		range.underlineColor= null;
		range.underlineStyle= SWT.UNDERLINE_SINGLE;
		fTextPresentation.mergeStyleRange((StyleRange) range.clone());

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);

		fTextPresentation.replaceStyleRange((StyleRange) range.clone());

		expectedAllRanges[1]= range;
		expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange( 47,  54, BOLD),
				createStyleRange( 96, 102, BOLD),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	@Test
	public void testMergeStyleRanges1() {
		StyleRange[] ranges= new StyleRange[] {
				createStyleRange(  0,   2, NORMAL, 1, -1), // at start of first existing
				createStyleRange( 20,  22, NORMAL, 1, -1), // at start of existing default
				createStyleRange( 24,  26, NORMAL, 1, -1), // within existing default
				createStyleRange( 45,  47, NORMAL, 1, -1), // at end of existing default
				createStyleRange( 47,  49, NORMAL, 1, -1), // at start of existing non-default
				createStyleRange( 50,  51, NORMAL, 1, -1), // within existing non-default
				createStyleRange( 52,  54, NORMAL, 1, -1), // at end of existing non-default
				createStyleRange(138, 140, NORMAL, 1, -1), // at end of last existing
		};
		fTextPresentation.mergeStyleRanges(deepClone(ranges));

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   2, NORMAL, 1, -1),
				createStyleRange(  2,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  22, NORMAL, 1, -1),
				createStyleRange( 22,  24, NORMAL),
				createStyleRange( 24,  26, NORMAL, 1, -1),
				createStyleRange( 26,  45, NORMAL),
				createStyleRange( 45,  47, NORMAL, 1, -1),
				createStyleRange( 47,  49, BOLD,   1, -1),
				createStyleRange( 49,  50, BOLD),
				createStyleRange( 50,  51, BOLD,   1, -1),
				createStyleRange( 51,  52, BOLD),
				createStyleRange( 52,  54, BOLD,   1, -1),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 138, NORMAL),
				createStyleRange(138, 140, NORMAL, 1, -1),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  0,   2, NORMAL, 1, -1),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  22, NORMAL, 1, -1),
				createStyleRange( 24,  26, NORMAL, 1, -1),
				createStyleRange( 45,  47, NORMAL, 1, -1),
				createStyleRange( 47,  49, BOLD,   1, -1),
				createStyleRange( 49,  50, BOLD),
				createStyleRange( 50,  51, BOLD,   1, -1),
				createStyleRange( 51,  52, BOLD),
				createStyleRange( 52,  54, BOLD,   1, -1),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(138, 140, NORMAL, 1, -1),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);

		// now swap fore- and background colors for an easy additional test
		for (StyleRange r : ranges) {
			Color c= r.foreground;
			r.foreground= r.background;
			r.background= c;
		}
		for (StyleRange[] rs : new StyleRange[][] { expectedAllRanges, expectedNonDefaultRanges }) {
			for (StyleRange r : rs) {
				r.background= r.foreground;
			}
		}
		fTextPresentation.mergeStyleRanges(ranges);
		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	@Test
	public void testReplaceStyleRanges1() {
		StyleRange[] ranges= new StyleRange[] {
				createStyleRange(  0,   2, NORMAL, 1, -1), // at start of first existing
				createStyleRange( 20,  22, NORMAL, 1, -1), // at start of existing default
				createStyleRange( 24,  26, NORMAL, 1, -1), // within existing default
				createStyleRange( 45,  47, NORMAL, 1, -1), // at end of existing default
				createStyleRange( 47,  49, NORMAL, 1, -1), // at start of existing non-default
				createStyleRange( 50,  51, NORMAL, 1, -1), // within existing non-default
				createStyleRange( 52,  54, NORMAL, 1, -1), // at end of existing non-default
				createStyleRange(138, 140, NORMAL, 1, -1), // at end of last existing
		};
		fTextPresentation.replaceStyleRanges(deepClone(ranges));

		StyleRange[] expectedAllRanges= new StyleRange[] {
				createStyleRange(  0,   2, NORMAL, 1, -1),
				createStyleRange(  2,   4, NORMAL),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  22, NORMAL, 1, -1),
				createStyleRange( 22,  24, NORMAL),
				createStyleRange( 24,  26, NORMAL, 1, -1),
				createStyleRange( 26,  45, NORMAL),
				createStyleRange( 45,  47, NORMAL, 1, -1),
				createStyleRange( 47,  49, NORMAL, 1, -1),
				createStyleRange( 49,  50, BOLD),
				createStyleRange( 50,  51, NORMAL, 1, -1),
				createStyleRange( 51,  52, BOLD),
				createStyleRange( 52,  54, NORMAL, 1, -1),
				createStyleRange( 54,  96, NORMAL),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(102, 138, NORMAL),
				createStyleRange(138, 140, NORMAL, 1, -1),
		};

		StyleRange[] expectedNonDefaultRanges= new StyleRange[] {
				createStyleRange(  0,   2, NORMAL, 1, -1),
				createStyleRange(  4,  20, BOLD),
				createStyleRange( 20,  22, NORMAL, 1, -1),
				createStyleRange( 24,  26, NORMAL, 1, -1),
				createStyleRange( 45,  47, NORMAL, 1, -1),
				createStyleRange( 47,  49, NORMAL, 1, -1),
				createStyleRange( 49,  50, BOLD),
				createStyleRange( 50,  51, NORMAL, 1, -1),
				createStyleRange( 51,  52, BOLD),
				createStyleRange( 52,  54, NORMAL, 1, -1),
				createStyleRange( 96, 102, BOLD),
				createStyleRange(138, 140, NORMAL, 1, -1),
		};

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);

		// now swap all fore- and background colors for an easy additional test
		for (StyleRange[] rs : new StyleRange[][] { ranges, expectedAllRanges, expectedNonDefaultRanges }) {
			for (StyleRange r : rs) {
				Color c= r.foreground;
				r.foreground= r.background;
				r.background= c;
			}
		}
		fTextPresentation.replaceStyleRanges(ranges);
		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	/**
	 * Replace whole presentation.
	 */
	@Test
	public void testReplaceStyleRange2() {
		StyleRange range= createStyleRange(0, 140, BOLD, 1, -1);
		fTextPresentation.replaceStyleRange(range);

		Color expectedColor= createColor(1, 1, 1);
		StyleRange[] expectedAllRanges= new StyleRange[fAllRanges.length];
		for (int i= 0; i < fAllRanges.length; i++) {
			expectedAllRanges[i]= (StyleRange) fAllRanges[i].clone();
			expectedAllRanges[i].fontStyle= BOLD;
			expectedAllRanges[i].foreground= expectedColor;
		}

		StyleRange[] expectedNonDefaultRanges= expectedAllRanges;

		checkRegions(expectedAllRanges, expectedNonDefaultRanges);
	}

	@Test
	public void testExtend() {
		fTextPresentation.setDefaultStyleRange(null);
		assertEquals(new Region(0, 140), fTextPresentation.getExtent());
		fTextPresentation.setDefaultStyleRange(createStyleRange(0, 150, NORMAL));
		assertEquals(new Region(0, 150), fTextPresentation.getExtent());
		fTextPresentation.setDefaultStyleRange(null);
		fTextPresentation.setResultWindow(new Region(100, 10));
		assertEquals(new Region(0, 10), fTextPresentation.getExtent());
		fTextPresentation.setDefaultStyleRange(createStyleRange(0, 150, NORMAL));
		assertEquals(new Region(0, 10), fTextPresentation.getExtent());

		fTextPresentation= new TextPresentation(new Region(0, 160), 10);
		assertEquals(new Region(0, 160), fTextPresentation.getExtent());
		fTextPresentation.setDefaultStyleRange(createStyleRange(0, 150, NORMAL));
		assertEquals(new Region(0, 160), fTextPresentation.getExtent());
		fTextPresentation.setDefaultStyleRange(null);
		fTextPresentation.setResultWindow(new Region(100, 10));
		assertEquals(new Region(0, 10), fTextPresentation.getExtent());
		fTextPresentation.setDefaultStyleRange(createStyleRange(0, 150, NORMAL));
		assertEquals(new Region(0, 10), fTextPresentation.getExtent());
	}

	@Test
	public void testExtendUndefined() {
		fTextPresentation= new TextPresentation(new Region(0, 160), 10);
		fTextPresentation.setResultWindow(new Region(-10, 5));
		assertEquals(new Region(10, -5), fTextPresentation.getExtent());
		fTextPresentation.setResultWindow(new Region(-10, 30));
		assertEquals(new Region(10, 20), fTextPresentation.getExtent());
		fTextPresentation.setResultWindow(new Region(150, 30));
		assertEquals(new Region(0, 10), fTextPresentation.getExtent());
		fTextPresentation.setResultWindow(new Region(200, 30));
		assertEquals(new Region(0, -40), fTextPresentation.getExtent());
	}

	@Test
	public void testEmptyPresentation() {
		fTextPresentation.clear();
		checkRegions(new StyleRange[0], new StyleRange[0]);
		fTextPresentation.setResultWindow(new Region(4, 10));
		checkRegions(new StyleRange[0], new StyleRange[0]);
		fTextPresentation.setResultWindow(null);

		StyleRange defaultRange= createStyleRange(0, 50, BOLD);
		fTextPresentation.setDefaultStyleRange(defaultRange);
		checkRegions(new StyleRange[0], new StyleRange[0]);
		fTextPresentation.setResultWindow(new Region(4, 10));
		checkRegions(new StyleRange[0], new StyleRange[0]);

		fTextPresentation= new TextPresentation(new Region(0, 100), 1);
		assertEquals(new Region(0, 100), fTextPresentation.getExtent());
		fTextPresentation.setResultWindow(new Region(4, 10));
		assertEquals(new Region(0, 10), fTextPresentation.getExtent());
	}

	@Test
	public void testApplyTextPresentation() {
		Shell shell= new Shell(fDisplay);
		try {
			StyledText text= new StyledText(shell, SWT.NONE);
			text.setText(String.join("", Collections.nCopies(fTextPresentation.getCoverage().getLength(), ".")));
			TextPresentation.applyTextPresentation(fTextPresentation, text);
			assertArrayEquals(fAllRanges, text.getStyleRanges());
		} finally {
			shell.dispose();
		}
	}

	@Test
	public void testIterator() {
		// Test read over iterator end
		Iterator<StyleRange> e= fTextPresentation.getAllStyleRangeIterator();
		try {
			for (int i= 0; i < 1000; i++) {
				e.next();
			}
			fail("Iterator has no end.");
		} catch (NoSuchElementException ex) {
			// expected
		}
		e= fTextPresentation.getNonDefaultStyleRangeIterator();
		try {
			for (int i= 0; i < 1000; i++) {
				e.next();
			}
			fail("Iterator has no end.");
		} catch (NoSuchElementException ex) {
			// expected
		}
	}

	// helper method required as long as TextPresentation methods manipulate given arguments
	private static StyleRange[] deepClone(StyleRange[] original) {
		StyleRange[] clone= new StyleRange[original.length];
		for (int i= 0; i < original.length; i++) {
			clone[i]= (StyleRange) original[i].clone();
		}
		return clone;
	}
}