Attachment #200743 for bug #183164

View | Details | Raw Unified | Return to bug 183164 | Differences between

and this patch





package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.STextHandler;
import org.eclipse.equinox.bidi.STextProcessorFactory;

import org.eclipse.equinox.bidi.STextEngine;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**

		data = "ABC.DEF:HOST-COM=HELLO";
		lean = toUT16(data);
		processor = STextProcessorFactory.getProcessor("test");
		STextHandler handler = new STextHandler(processor);
		full = handler.leanToFullText(null, lean);
		model = "ABC@.DEF@:HOST@-COM@=HELLO";
		assertEquals("Test 'test' plugin", model, toPseudo(full));
	}




package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.*;
import org.eclipse.equinox.bidi.custom.STextCharTypes;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**

	STextEnvironment envHebrew = new STextEnvironment("he", false, STextEnvironment.ORIENT_LTR);

	STextProcessor processor;
	STextHandler handler;

	private void doTest1(String label, String data, String result) {
		String full;
		full = handler.leanToFullText(env, toUT16(data));
		assertEquals(label + " data = " + data, result, toPseudo(full));
	}

	private void doTest2(String label, String data, String result) {
		String full;
		full = handler.leanToFullText(env, data);
		assertEquals(label + " data = " + data, result, toPseudo(full));
	}

	private void doTest3(String label, String data, String result) {
		String full;
		full = handler.leanToFullText(env, toUT16(data));
		assertEquals(label + " data = " + data, result, toPseudo(full));
	}

	private void doTestGetDirection() {
		STextEnvironment envRTL = new STextEnvironment("ar", false, STextEnvironment.ORIENT_RTL);
		String[] types = STextProcessorFactory.getAllProcessorIDs();
		assertNotNull(types);
		assertTrue(types.length > 0);
		String text = "\u0644\u0645 \u05d0\u05d1";
		STextCharTypes dirProps = new STextCharTypes(text);
		for (int i = 0; i < types.length; i++) {
			processor = STextProcessorFactory.getProcessor(types[i]);
			assertNotNull(processor);
			int dir1 = processor.getDirection(envRTL, text);
			int dir2 = processor.getDirection(envRTL, text, dirProps);
			assertEquals("getDirection: comparing " + dir1 + "  with " + dir2, dir1, dir2);
		}
	}

	public void testExtensions() {

		String data;
		processor = STextProcessorFactory.PROC_COMMA_DELIMITED;
		handler = new STextHandler(processor);

		doTest1("Comma #1", "ab,cd, AB, CD, EFG", "ab,cd, AB@, CD@, EFG");

		processor = STextProcessorFactory.PROC_EMAIL;
		handler.setProcessor(processor);
		doTest1("Email #1", "abc.DEF:GHI", "abc.DEF@:GHI");
		doTest1("Email #2", "DEF.GHI \"A.B\":JK ", "DEF@.GHI @\"A.B\"@:JK ");
		doTest1("Email #3", "DEF,GHI (A,B);JK ", "DEF@,GHI @(A,B)@;JK ");

		doTest2("Email #9", data, "peter.pan@DEF@.GHI");

		processor = STextProcessorFactory.PROC_FILE;
		handler.setProcessor(processor);
		doTest1("File #1", "c:\\A\\B\\FILE.EXT", "c:\\A@\\B@\\FILE@.EXT");

		processor = STextProcessorFactory.PROC_JAVA;
		handler.setProcessor(processor);
		doTest1("Java #1", "A = B + C;", "A@ = B@ + C;");
		doTest1("Java #2", "A   = B + C;", "A@   = B@ + C;");
		doTest1("Java #3", "A = \"B+C\"+D;", "A@ = \"B+C\"@+D;");

		doTest1("Java #10", "A = //B+C`|D+E;", "A@ = //B+C`|D@+E;");

		processor = STextProcessorFactory.PROC_PROPERTY;
		handler.setProcessor(processor);
		doTest1("Property #0", "NAME,VAL1,VAL2", "NAME,VAL1,VAL2");
		doTest1("Property #1", "NAME=VAL1,VAL2", "NAME@=VAL1,VAL2");
		doTest1("Property #2", "NAME=VAL1,VAL2=VAL3", "NAME@=VAL1,VAL2=VAL3");

		processor = STextProcessorFactory.PROC_REGEXP;
		handler.setProcessor(processor);
		data = toUT16("ABC(?") + "#" + toUT16("DEF)GHI");
		doTest2("Regex #0.0", data, "A@B@C@(?#DEF)@G@H@I");
		data = toUT16("ABC(?") + "#" + toUT16("DEF");

		env = envHebrew;

		processor = STextProcessorFactory.PROC_SQL;
		handler.setProcessor(processor);
		doTest1("SQL #0", "abc GHI", "abc GHI");
		doTest1("SQL #1", "abc DEF   GHI", "abc DEF@   GHI");
		doTest1("SQL #2", "ABC, DEF,   GHI", "ABC@, DEF@,   GHI");

		doTest1("SQL #13", "ABC--DEF GHI`|JKL MN", "ABC@--DEF GHI`|JKL@ MN");

		processor = STextProcessorFactory.PROC_SYSTEM_USER;
		handler.setProcessor(processor);
		doTest1("System #1", "HOST(JACK)", "HOST@(JACK)");

		processor = STextProcessorFactory.PROC_UNDERSCORE;
		handler.setProcessor(processor);
		doTest1("Underscore #1", "A_B_C_d_e_F_G", "A@_B@_C_d_e_F@_G");

		processor = STextProcessorFactory.PROC_URL;
		handler.setProcessor(processor);
		doTest1("URL #1", "WWW.DOMAIN.COM/DIR1/DIR2/dir3/DIR4", "WWW@.DOMAIN@.COM@/DIR1@/DIR2/dir3/DIR4");

		processor = STextProcessorFactory.PROC_XPATH;
		handler.setProcessor(processor);
		doTest1("Xpath #1", "abc(DEF)GHI", "abc(DEF@)GHI");
		doTest1("Xpath #2", "DEF.GHI \"A.B\":JK ", "DEF@.GHI@ \"A.B\"@:JK ");
		doTest1("Xpath #3", "DEF!GHI 'A!B'=JK ", "DEF@!GHI@ 'A!B'@=JK ");
		doTest1("Xpath #4", "DEF.GHI 'A.B :JK ", "DEF@.GHI@ 'A.B :JK ");

		processor = STextProcessorFactory.PROC_EMAIL;
		handler.setProcessor(processor);
		assertEquals("<>.:,;@", processor.getSeparators(null));
		doTest3("DelimsEsc #1", "abc.DEF.GHI", "abc.DEF@.GHI");
		doTest3("DelimsEsc #2", "DEF.GHI (A:B);JK ", "DEF@.GHI @(A:B)@;JK ");

		doTest3("DelimsEsc #5", "DEF.GHI (A\\\\\\):C) ;JK ", "DEF@.GHI @(A\\\\\\):C) @;JK ");
		doTest3("DelimsEsc #6", "DEF.GHI (A\\\\):C ;JK ", "DEF@.GHI @(A\\\\)@:C @;JK ");
		doTest3("DelimsEsc #7", "DEF.GHI (A\\):C ;JK ", "DEF@.GHI @(A\\):C ;JK ");

		doTestGetDirection();
	}
}




	static final STextEnvironment envRTL = new STextEnvironment(null, false, STextEnvironment.ORIENT_RTL);

	STextProcessor processor;
	STextHandler handler = new STextHandler(null);

	private void doTest1(String msg, String data, String leanLTR, String fullLTR, int[] l2fMapLTR, int[] f2lMapLTR, String leanRTL, String fullRTL, int[] l2fMapRTL, int[] f2lMapRTL) {
		String text, full, lean, label;
		int[] map;

		text = toUT16(data);
		lean = handler.fullToLeanText(envLTR, text);
		assertEquals(msg + "LTR lean", leanLTR, toPseudo(lean));
		full = handler.leanToFullText(envLTR, lean);
		assertEquals(msg + "LTR full", fullLTR, toPseudo(full));
		map = handler.leanToFullMap(envLTR, lean);
		label = msg + "leanToFullMap() LTR";
		assertEquals(label, array_display(l2fMapLTR), array_display(map));
		map = handler.fullToLeanMap(envLTR, text);
		label = msg + "fullToLeanMap() LTR";
		assertEquals(label, array_display(f2lMapLTR), array_display(map));

		lean = handler.fullToLeanText(envRTL, text);
		assertEquals(msg + "RTL lean", leanRTL, toPseudo(lean));
		full = handler.leanToFullText(envRTL, lean);
		assertEquals(msg + "RTL full", fullRTL, toPseudo(full));
		map = handler.leanToFullMap(envRTL, lean);
		label = msg + "leanToFullMap() RTL";
		assertEquals(label, array_display(l2fMapRTL), array_display(map));
		map = handler.fullToLeanMap(envRTL, text);
		label = msg + "fullToLeanMap() RTL";
		assertEquals(label, array_display(f2lMapRTL), array_display(map));
	}

	private void doTest2(String msg) {
		String text, data, full, lean, model;
		int state;
		int state1, state2, state3;

		data = "update \"AB_CDE\" set \"COL1\"@='01', \"COL2\"@='02' /* GH IJK";
		text = toUT16(data);
		state = -1;
		handler.setState(state);
		lean = handler.fullToLeanText(envLTR, text);
		state1 = handler.getState();
		model = "update \"AB_CDE\" set \"COL1\"='01', \"COL2\"='02' /* GH IJK";
		assertEquals(msg + "LTR lean", model, toPseudo(lean));
		state = -1;
		handler.setState(state);
		full = handler.leanToFullText(envLTR, lean);
		assertEquals(msg + "LTR full", data, toPseudo(full));
		state = handler.getState();
		assertEquals(msg + "state from leanToFullText", state1, state);
		data = "THIS IS A COMMENT LINE";
		text = toUT16(data);
		state = state1;
		handler.setState(state);
		lean = handler.fullToLeanText(envLTR, text);
		state2 = handler.getState();
		model = "THIS IS A COMMENT LINE";
		assertEquals(msg + "LTR lean2", model, toPseudo(lean));
		state = state1;
		handler.setState(state);
		full = handler.leanToFullText(envLTR, lean);
		state = handler.getState();
		assertEquals(msg + "LTR full2", data, toPseudo(full));
		assertEquals(msg + "state from leanToFullText2", state2, state);
		data = "SOME MORE */ where \"COL3\"@=123";
		text = toUT16(data);
		state = state2;
		handler.setState(state);
		lean = handler.fullToLeanText(envLTR, text);
		state3 = handler.getState();
		model = "SOME MORE */ where \"COL3\"=123";
		assertEquals(msg + "LTR lean3", model, toPseudo(lean));
		state = state2;
		handler.setState(state);
		full = handler.leanToFullText(envLTR, lean);
		state = handler.getState();
		assertEquals(msg + "LTR full3", data, toPseudo(full));
		assertEquals(msg + "state from leanToFullText3", state3, state);
	}

	public void testFullToLean() {

		processor = STextProcessorFactory.PROC_COMMA_DELIMITED;
		handler.setProcessor(processor);
		doTest1("testFullToLean #1 - ", "", "", "", new int[0], new int[0], "", "", new int[0], new int[0]);
		int[] map1 = new int[] {0, 1, 2, 3, 4};
		int[] map2 = new int[] {2, 3, 4, 5, 6};


		// test fullToLeanText with initial state
		processor = STextProcessorFactory.PROC_SQL;
		handler.setProcessor(processor);
		doTest2("testFullToLean #38 - ");
	}
}




	static final STextEnvironment envRTL = new STextEnvironment("ar", false, STextEnvironment.ORIENT_RTL);

	STextProcessor processor = STextProcessorFactory.PROC_RTL_ARITHMETIC;
	STextHandler handler = new STextHandler(processor);

	private void verifyOneLine(String msg, String data, String resLTR, String resRTL) {
		String lean = toUT16(data);
		String fullLTR = handler.leanToFullText(envLTR, lean);
		assertEquals(msg + " LTR - ", resLTR, toPseudo(fullLTR));
		String fullRTL = handler.leanToFullText(envRTL, lean);
		assertEquals(msg + " RTL - ", resRTL, toPseudo(fullRTL));
	}





package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.*;
import org.eclipse.equinox.bidi.custom.*;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**
 * Tests most public methods of BidiComplexEngine


public class STextMethodsTest extends STextTestBase {

	final static int LTR = STextHandler.DIR_LTR;
	final static int RTL = STextHandler.DIR_RTL;
	final static STextEnvironment envLTR = new STextEnvironment(null, false, STextEnvironment.ORIENT_LTR);
	final static STextEnvironment envRTL = new STextEnvironment(null, false, STextEnvironment.ORIENT_RTL);
	final static STextEnvironment envRTLMIR = new STextEnvironment(null, true, STextEnvironment.ORIENT_RTL);

			return ","; //$NON-NLS-1$
		}

		public boolean skipProcessing(STextProcessorData procData) {
			byte dirProp = procData.dirProps.getBidiTypeAt(0);
			if (dirProp == AL)
				return true;
			return false;

	}

	STextProcessor processor;
	STextHandler handler = new STextHandler(null);

	private void doTestTools() {



	private void doTestState() {
		String data, lean, full, model;
		int[] state = new int[1];
		state[0] = -1;
		processor = STextProcessorFactory.PROC_JAVA;
		handler.setProcessor(processor);
		data = "A=B+C;/* D=E+F;";
		lean = toUT16(data);
		full = handler.leanToFullText(null, lean);
		model = "A@=B@+C@;/* D=E+F;";
		assertEquals("full1", model, toPseudo(full));
		data = "A=B+C; D=E+F;";
		lean = toUT16(data);
		full = handler.leanToFullText(null, lean);
		model = "A=B+C; D=E+F;";
		assertEquals("full2", model, toPseudo(full));
		data = "A=B+C;*/ D=E+F;";
		lean = toUT16(data);
		full = handler.leanToFullText(null, lean);
		model = "A=B+C;@*/ D@=E@+F;";
		assertEquals("full3", model, toPseudo(full));
	}

		String full, lean;

		lean = toUT16(data);
		full = handler.leanToFullText(envLTR, lean);
		assertEquals(label + "LTR full", resLTR, toPseudo(full));
		full = handler.leanToFullText(envRTL, lean);
		assertEquals("label + RTL full", resRTL, toPseudo(full));
		full = handler.leanToFullText(envCRL, lean);
		assertEquals(label + "CON full", resCon, toPseudo(full));
	}

	private void doTestSkipProcessing() {
		processor = new MyComma();
		handler.setProcessor(processor);
		doTestOrient("Skip #1 ", "BCD,EF", "BCD@,EF", ">@BCD@,EF@^", "@BCD@,EF");
		doTestOrient("Skip #2 ", "#CD,EF", "#CD,EF", ">@#CD,EF@^", "@#CD,EF");
	}

	private void doTestLeanOffsets() {
		String lean, data, label;
		int[] state = new int[1];
		processor = STextProcessorFactory.PROC_JAVA;
		handler.setProcessor(processor);
		int[] offsets;
		int[] model;

		data = "A=B+C;/* D=E+F;";
		lean = toUT16(data);
		offsets = handler.leanBidiCharOffsets(null, lean);
		offsets = STextEngine.leanBidiCharOffsets(processor, null, lean, state);
		model = new int[] {1, 3, 5};
		label = "leanBidiCharOffsets() #1 ";
		assertEquals(label, array_display(model), array_display(offsets));
		data = "A=B+C;*/ D=E+F;";
		lean = toUT16(data);
		offsets = handler.leanBidiCharOffsets(null, lean);
		model = new int[] {6, 10, 12};
		label = "leanBidiCharOffsets() #2 ";
		assertEquals(label, array_display(model), array_display(offsets));

		String full, lean, msg;
		int[] offsets;
		processor = STextProcessorFactory.PROC_COMMA_DELIMITED;
		handler.setProcessor(processor);

		lean = toUT16(data);
		full = handler.leanToFullText(envLTR, lean);
		offsets = handler.fullBidiCharOffsets(envLTR, full);
		msg = label + "LTR ";
		assertEquals(msg, array_display(resLTR), array_display(offsets));
		full = handler.leanToFullText(envRTL, lean);
		offsets = handler.fullBidiCharOffsets(envRTL, full);
		msg = label + "RTL ";
		assertEquals(msg, array_display(resRTL), array_display(offsets));
		full = handler.leanToFullText(envCLR, lean);
		offsets = handler.fullBidiCharOffsets(envCLR, full);
		msg = label + "CON ";
		assertEquals(msg, array_display(resCon), array_display(offsets));
	}

		String data, lean, full, model, msg;
		int dirA, dirH;
		processor = new MyComma();
		handler.setProcessor(processor);
		dirArabic = RTL;
		dirHebrew = LTR;
		msg = "TestDirection #1";

		msg = "TestDirection #3";
		data = "ABC,#DEF,HOST,com";
		lean = toUT16(data);
		full = handler.leanToFullText(null, lean);
		model = "ABC@,#DEF@,HOST,com";
		assertEquals("TestDirection #9 full", model, toPseudo(full));

		data = "ABC,DEF,HOST,com";
		lean = toUT16(data);
		full = handler.leanToFullText(null, lean);
		model = "ABC@,DEF@,HOST,com";
		assertEquals("TestDirection #10 full", model, toPseudo(full));


		STextEnvironment environment = new STextEnvironment(null, true, STextEnvironment.ORIENT_LTR);
		data = "ABC,#DEF,HOST,com";
		lean = toUT16(data);
		full = handler.leanToFullText(environment, lean);
		model = "<&ABC,#DEF,HOST,com&^";
		assertEquals("TestDirection #11 full", model, toPseudo(full));

		data = "ABc,#DEF,HOSt,COM";
		lean = toUT16(data);
		full = handler.leanToFullText(environment, lean);
		model = "<&ABc,#DEF,HOSt,COM&^";
		assertEquals("TestDirection #12 full", model, toPseudo(full));

		data = "ABc,#DEF,HOSt,";
		lean = toUT16(data);
		full = handler.leanToFullText(environment, lean);
		model = "<&ABc,#DEF,HOSt,&^";
		assertEquals("TestDirection #13 full", model, toPseudo(full));

		data = "ABC,DEF,HOST,com";
		lean = toUT16(data);
		full = handler.leanToFullText(environment, lean);
		model = "ABC@,DEF@,HOST,com";
		assertEquals("TestDirection #14 full", model, toPseudo(full));

		data = "--,---,----";
		lean = toUT16(data);
		full = handler.leanToFullText(environment, lean);
		model = "--,---,----";
		assertEquals("TestDirection #15 full", model, toPseudo(full));

		data = "ABC,|DEF,HOST,com";
		lean = toUT16(data);
		full = handler.leanToFullText(environment, lean);
		model = "ABC,|DEF@,HOST,com";
		assertEquals("TestDirection #16 full", model, toPseudo(full));

		data = "ABc,|#DEF,HOST,com";
		lean = toUT16(data);
		full = handler.leanToFullText(envRTLMIR, lean);
		model = "ABc,|#DEF,HOST,com";
		assertEquals("TestDirection #17 full", model, toPseudo(full));
		assertEquals("Test curDirection", RTL, handler.getCurDirection(envRTLMIR, lean));
	}

	public void testMethods() {

		doTestOrientation();

		processor = STextProcessorFactory.PROC_COMMA_DELIMITED;
		handler.setProcessor(processor);
		doTestOrient("Methods #1 ", "", "", "", "");
		doTestOrient("Methods #2 ", "abc", "abc", ">@abc@^", "abc");
		doTestOrient("Methods #3 ", "ABC", "ABC", ">@ABC@^", "@ABC");

		doTestDirection();

		processor = STextProcessorFactory.PROC_COMMA_DELIMITED;
		handler.setProcessor(processor);
		String data = "A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z";
		String lean = toUT16(data);
		String full = handler.leanToFullText(null, lean);
		String model = "A@,B@,C@,D@,E@,F@,G@,H@,I@,J@,K@,L@,M@,N@,O@,P@,Q@,R@,S@,T@,U@,V@,W@,X@,Y@,Z";
		assertEquals("many inserts", model, toPseudo(full));
	}





package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.STextHandler;

/**
 * Tests null processor

public class STextNullProcessorTest extends STextTestBase {

	static final int[] EMPTY_INT_ARRAY = new int[0];

	STextHandler handler = new STextHandler(null);

	public void testNullProcessor() {
		String full = handler.leanToFullText(null, "abc");
		assertEquals("leanToFullText", "abc", full);
		handler.setState(3);
		full = handler.leanToFullText(null, "abc");
		full = STextEngine.leanToFullText(null, null, "abc", state);
		assertEquals("leanToFullText with state", "abc", full);
		int[] offsets = handler.leanBidiCharOffsets(null, "abc");
		assertEquals("leanBidiCharOffsets", 0, offsets.length);
		offsets = handler.fullBidiCharOffsets(null, "abc");
		assertEquals("fullBidiCharOffsets", 0, offsets.length);
		String lean = handler.fullToLeanText(null, "abc");
		assertEquals("fullToLeanText", "abc", lean);
		handler.setState(3);
		lean = handler.fullToLeanText(null, "abc");
		assertEquals("fullToLeanText with state", "abc", lean);
		int[] map = handler.leanToFullMap(null, "abc");
		int[] model = {0, 1, 2};
		assertEquals("leanToFullMap", array_display(model), array_display(map));
		map = handler.fullToLeanMap(null, "abc");
		assertEquals("fullToLeanMap", array_display(model), array_display(map));
		int direction = handler.getCurDirection(null, "abc");
		assertEquals("getCurDirection", STextHandler.DIR_LTR, direction);
	}

}





package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.STextEngine;
import org.eclipse.equinox.bidi.STextEnvironment;
import org.eclipse.equinox.bidi.STextHandler;
import org.eclipse.equinox.bidi.custom.STextProcessor;
import org.eclipse.equinox.bidi.custom.STextProcessorData;

/**
 * Tests some weird cases

			return 1;
		}

		public int indexOfSpecial(STextProcessorData procData, int caseNumber, int fromIndex) {
			return fromIndex;
		}

		public int processSpecial(STextProcessorData procData, int caseNumber, int separLocation) {
			String text = procData.text;
			int len = text.length();
			for (int i = len - 1; i >= 0; i--) {
				STextProcessor.insertMark(procData, i);
				STextProcessor.insertMark(procData, i);
			}
			return len;
		}

			return 1;
		}

		public int indexOfSpecial(STextProcessorData procData, int caseNumber, int fromIndex) {
			return fromIndex;
		}
	}

		assertTrue(env2.isProcessingNeeded());

		STextProcessor processor = new Processor1();
		STextHandler handler = new STextHandler(processor);
		String full = handler.leanToFullText(env1, "abcd");
		assertEquals("@a@b@c@d", toPseudo(full));

		processor = new Processor2();
		handler.setProcessor(processor);
		boolean catchFlag = false;
		try {
			full = handler.leanToFullText(env1, "abcd");
		} catch (IllegalStateException e) {
			catchFlag = true;
		}
		assertTrue("Catch missing indexOfSpecial", catchFlag);

		processor = new Processor3();
		handler.setProcessor(processor);
		catchFlag = false;
		try {
			full = handler.leanToFullText(env1, "abcd");
		} catch (IllegalStateException e) {
			catchFlag = true;
		}

Return to bug 183164

Lines 12-17 Link Here

(-)src/org/eclipse/equinox/bidi/internal/tests/STextExtensionsTest.java (-16 / +35 lines)
12	package org.eclipse.equinox.bidi.internal.tests;	12	package org.eclipse.equinox.bidi.internal.tests;
13		13
14	import org.eclipse.equinox.bidi.*;	14	import org.eclipse.equinox.bidi.*;
		15	import org.eclipse.equinox.bidi.custom.STextCharTypes;
15	import org.eclipse.equinox.bidi.custom.STextProcessor;	16	import org.eclipse.equinox.bidi.custom.STextProcessor;
16		17
17	/**	18	/**
Lines 25-60 Link Here
25	STextEnvironment envHebrew = new STextEnvironment("he", false, STextEnvironment.ORIENT_LTR);	26	STextEnvironment envHebrew = new STextEnvironment("he", false, STextEnvironment.ORIENT_LTR);
26		27
27	STextProcessor processor;	28	STextProcessor processor;
28	int[] state = new int[1];	29	STextHandler handler;
29		30
30	private void doTest1(String label, String data, String result) {	31	private void doTest1(String label, String data, String result) {
31	String full;	32	String full;
32	full = STextEngine.leanToFullText(processor, env, toUT16(data), state);	33	full = handler.leanToFullText(env, toUT16(data));
33	assertEquals(label + " data = " + data, result, toPseudo(full));	34	assertEquals(label + " data = " + data, result, toPseudo(full));
34	}	35	}
35		36
36	private void doTest2(String label, String data, String result) {	37	private void doTest2(String label, String data, String result) {
37	String full;	38	String full;
38	full = STextEngine.leanToFullText(processor, env, data, state);	39	full = handler.leanToFullText(env, data);
39	assertEquals(label + " data = " + data, result, toPseudo(full));	40	assertEquals(label + " data = " + data, result, toPseudo(full));
40	}	41	}
41		42
42	private void doTest3(String label, String data, String result) {	43	private void doTest3(String label, String data, String result) {
43	String full;	44	String full;
44	full = STextEngine.leanToFullText(processor, env, toUT16(data), state);	45	full = handler.leanToFullText(env, toUT16(data));
45	assertEquals(label + " data = " + data, result, toPseudo(full));	46	assertEquals(label + " data = " + data, result, toPseudo(full));
		47	}
		48
		49	private void doTestGetDirection() {
		50	STextEnvironment envRTL = new STextEnvironment("ar", false, STextEnvironment.ORIENT_RTL);
		51	String[] types = STextProcessorFactory.getAllProcessorIDs();
		52	assertNotNull(types);
		53	assertTrue(types.length > 0);
		54	String text = "\u0644\u0645 \u05d0\u05d1";
		55	STextCharTypes dirProps = new STextCharTypes(text);
		56	for (int i = 0; i < types.length; i++) {
		57	processor = STextProcessorFactory.getProcessor(types[i]);
		58	assertNotNull(processor);
		59	int dir1 = processor.getDirection(envRTL, text);
		60	int dir2 = processor.getDirection(envRTL, text, dirProps);
		61	assertEquals("getDirection: comparing " + dir1 + " with " + dir2, dir1, dir2);
		62	}
46	}	63	}
47		64
48	public void testExtensions() {	65	public void testExtensions() {
49		66
50	String data;	67	String data;
51	processor = STextProcessorFactory.PROC_COMMA_DELIMITED;	68	processor = STextProcessorFactory.PROC_COMMA_DELIMITED;
52	state[0] = STextEngine.STATE_INITIAL;	69	handler = new STextHandler(processor);
53		70
54	doTest1("Comma #1", "ab,cd, AB, CD, EFG", "ab,cd, AB@, CD@, EFG");	71	doTest1("Comma #1", "ab,cd, AB, CD, EFG", "ab,cd, AB@, CD@, EFG");
55		72
56	processor = STextProcessorFactory.PROC_EMAIL;	73	processor = STextProcessorFactory.PROC_EMAIL;
57	state[0] = STextEngine.STATE_INITIAL;	74	handler.setProcessor(processor);
58	doTest1("Email #1", "abc.DEF:GHI", "abc.DEF@:GHI");	75	doTest1("Email #1", "abc.DEF:GHI", "abc.DEF@:GHI");
59	doTest1("Email #2", "DEF.GHI \"A.B\":JK ", "DEF@.GHI @\"A.B\"@:JK ");	76	doTest1("Email #2", "DEF.GHI \"A.B\":JK ", "DEF@.GHI @\"A.B\"@:JK ");
60	doTest1("Email #3", "DEF,GHI (A,B);JK ", "DEF@,GHI @(A,B)@;JK ");	77	doTest1("Email #3", "DEF,GHI (A,B);JK ", "DEF@,GHI @(A,B)@;JK ");
Lines 70-80 Link Here
70	doTest2("Email #9", data, "peter.pan@DEF@.GHI");	87	doTest2("Email #9", data, "peter.pan@DEF@.GHI");
71		88
72	processor = STextProcessorFactory.PROC_FILE;	89	processor = STextProcessorFactory.PROC_FILE;
73	state[0] = STextEngine.STATE_INITIAL;	90	handler.setProcessor(processor);
74	doTest1("File #1", "c:\\A\\B\\FILE.EXT", "c:\\A@\\B@\\FILE@.EXT");	91	doTest1("File #1", "c:\\A\\B\\FILE.EXT", "c:\\A@\\B@\\FILE@.EXT");
75		92
76	processor = STextProcessorFactory.PROC_JAVA;	93	processor = STextProcessorFactory.PROC_JAVA;
77	state[0] = STextEngine.STATE_INITIAL;	94	handler.setProcessor(processor);
78	doTest1("Java #1", "A = B + C;", "A@ = B@ + C;");	95	doTest1("Java #1", "A = B + C;", "A@ = B@ + C;");
79	doTest1("Java #2", "A = B + C;", "A@ = B@ + C;");	96	doTest1("Java #2", "A = B + C;", "A@ = B@ + C;");
80	doTest1("Java #3", "A = \"B+C\"+D;", "A@ = \"B+C\"@+D;");	97	doTest1("Java #3", "A = \"B+C\"+D;", "A@ = \"B+C\"@+D;");
Lines 87-99 Link Here
87	doTest1("Java #10", "A = //B+C`\|D+E;", "A@ = //B+C`\|D@+E;");	104	doTest1("Java #10", "A = //B+C`\|D+E;", "A@ = //B+C`\|D@+E;");
88		105
89	processor = STextProcessorFactory.PROC_PROPERTY;	106	processor = STextProcessorFactory.PROC_PROPERTY;
90	state[0] = STextEngine.STATE_INITIAL;	107	handler.setProcessor(processor);
91	doTest1("Property #0", "NAME,VAL1,VAL2", "NAME,VAL1,VAL2");	108	doTest1("Property #0", "NAME,VAL1,VAL2", "NAME,VAL1,VAL2");
92	doTest1("Property #1", "NAME=VAL1,VAL2", "NAME@=VAL1,VAL2");	109	doTest1("Property #1", "NAME=VAL1,VAL2", "NAME@=VAL1,VAL2");
93	doTest1("Property #2", "NAME=VAL1,VAL2=VAL3", "NAME@=VAL1,VAL2=VAL3");	110	doTest1("Property #2", "NAME=VAL1,VAL2=VAL3", "NAME@=VAL1,VAL2=VAL3");
94		111
95	processor = STextProcessorFactory.PROC_REGEXP;	112	processor = STextProcessorFactory.PROC_REGEXP;
96	state[0] = STextEngine.STATE_INITIAL;	113	handler.setProcessor(processor);
97	data = toUT16("ABC(?") + "#" + toUT16("DEF)GHI");	114	data = toUT16("ABC(?") + "#" + toUT16("DEF)GHI");
98	doTest2("Regex #0.0", data, "A@B@C@(?#DEF)@G@H@I");	115	doTest2("Regex #0.0", data, "A@B@C@(?#DEF)@G@H@I");
99	data = toUT16("ABC(?") + "#" + toUT16("DEF");	116	data = toUT16("ABC(?") + "#" + toUT16("DEF");
Lines 177-183 Link Here
177	env = envHebrew;	194	env = envHebrew;
178		195
179	processor = STextProcessorFactory.PROC_SQL;	196	processor = STextProcessorFactory.PROC_SQL;
180	state[0] = STextEngine.STATE_INITIAL;	197	handler.setProcessor(processor);
181	doTest1("SQL #0", "abc GHI", "abc GHI");	198	doTest1("SQL #0", "abc GHI", "abc GHI");
182	doTest1("SQL #1", "abc DEF GHI", "abc DEF@ GHI");	199	doTest1("SQL #1", "abc DEF GHI", "abc DEF@ GHI");
183	doTest1("SQL #2", "ABC, DEF, GHI", "ABC@, DEF@, GHI");	200	doTest1("SQL #2", "ABC, DEF, GHI", "ABC@, DEF@, GHI");
Lines 196-221 Link Here
196	doTest1("SQL #13", "ABC--DEF GHI`\|JKL MN", "ABC@--DEF GHI`\|JKL@ MN");	213	doTest1("SQL #13", "ABC--DEF GHI`\|JKL MN", "ABC@--DEF GHI`\|JKL@ MN");
197		214
198	processor = STextProcessorFactory.PROC_SYSTEM_USER;	215	processor = STextProcessorFactory.PROC_SYSTEM_USER;
199	state[0] = STextEngine.STATE_INITIAL;	216	handler.setProcessor(processor);
200	doTest1("System #1", "HOST(JACK)", "HOST@(JACK)");	217	doTest1("System #1", "HOST(JACK)", "HOST@(JACK)");
201		218
202	processor = STextProcessorFactory.PROC_UNDERSCORE;	219	processor = STextProcessorFactory.PROC_UNDERSCORE;
203	state[0] = STextEngine.STATE_INITIAL;	220	handler.setProcessor(processor);
204	doTest1("Underscore #1", "A_B_C_d_e_F_G", "A@_B@_C_d_e_F@_G");	221	doTest1("Underscore #1", "A_B_C_d_e_F_G", "A@_B@_C_d_e_F@_G");
205		222
206	processor = STextProcessorFactory.PROC_URL;	223	processor = STextProcessorFactory.PROC_URL;
207	state[0] = STextEngine.STATE_INITIAL;	224	handler.setProcessor(processor);
208	doTest1("URL #1", "WWW.DOMAIN.COM/DIR1/DIR2/dir3/DIR4", "WWW@.DOMAIN@.COM@/DIR1@/DIR2/dir3/DIR4");	225	doTest1("URL #1", "WWW.DOMAIN.COM/DIR1/DIR2/dir3/DIR4", "WWW@.DOMAIN@.COM@/DIR1@/DIR2/dir3/DIR4");
209		226
210	processor = STextProcessorFactory.PROC_XPATH;	227	processor = STextProcessorFactory.PROC_XPATH;
211	state[0] = STextEngine.STATE_INITIAL;	228	handler.setProcessor(processor);
212	doTest1("Xpath #1", "abc(DEF)GHI", "abc(DEF@)GHI");	229	doTest1("Xpath #1", "abc(DEF)GHI", "abc(DEF@)GHI");
213	doTest1("Xpath #2", "DEF.GHI \"A.B\":JK ", "DEF@.GHI@ \"A.B\"@:JK ");	230	doTest1("Xpath #2", "DEF.GHI \"A.B\":JK ", "DEF@.GHI@ \"A.B\"@:JK ");
214	doTest1("Xpath #3", "DEF!GHI 'A!B'=JK ", "DEF@!GHI@ 'A!B'@=JK ");	231	doTest1("Xpath #3", "DEF!GHI 'A!B'=JK ", "DEF@!GHI@ 'A!B'@=JK ");
215	doTest1("Xpath #4", "DEF.GHI 'A.B :JK ", "DEF@.GHI@ 'A.B :JK ");	232	doTest1("Xpath #4", "DEF.GHI 'A.B :JK ", "DEF@.GHI@ 'A.B :JK ");
216		233
217	processor = STextProcessorFactory.PROC_EMAIL;	234	processor = STextProcessorFactory.PROC_EMAIL;
218	state[0] = STextEngine.STATE_INITIAL;	235	handler.setProcessor(processor);
219	assertEquals("<>.:,;@", processor.getSeparators(null));	236	assertEquals("<>.:,;@", processor.getSeparators(null));
220	doTest3("DelimsEsc #1", "abc.DEF.GHI", "abc.DEF@.GHI");	237	doTest3("DelimsEsc #1", "abc.DEF.GHI", "abc.DEF@.GHI");
221	doTest3("DelimsEsc #2", "DEF.GHI (A:B);JK ", "DEF@.GHI @(A:B)@;JK ");	238	doTest3("DelimsEsc #2", "DEF.GHI (A:B);JK ", "DEF@.GHI @(A:B)@;JK ");
Lines 224-228 Link Here
224	doTest3("DelimsEsc #5", "DEF.GHI (A\\\\\\):C) ;JK ", "DEF@.GHI @(A\\\\\\):C) @;JK ");	241	doTest3("DelimsEsc #5", "DEF.GHI (A\\\\\\):C) ;JK ", "DEF@.GHI @(A\\\\\\):C) @;JK ");
225	doTest3("DelimsEsc #6", "DEF.GHI (A\\\\):C ;JK ", "DEF@.GHI @(A\\\\)@:C @;JK ");	242	doTest3("DelimsEsc #6", "DEF.GHI (A\\\\):C ;JK ", "DEF@.GHI @(A\\\\)@:C @;JK ");
226	doTest3("DelimsEsc #7", "DEF.GHI (A\\):C ;JK ", "DEF@.GHI @(A\\):C ;JK ");	243	doTest3("DelimsEsc #7", "DEF.GHI (A\\):C ;JK ", "DEF@.GHI @(A\\):C ;JK ");
		244
		245	doTestGetDirection();
227	}	246	}
228	}	247	}

Lines 24-101 Link Here

(-)src/org/eclipse/equinox/bidi/internal/tests/STextFullToLeanTest.java (-27 / +39 lines)
24	static final STextEnvironment envRTL = new STextEnvironment(null, false, STextEnvironment.ORIENT_RTL);	24	static final STextEnvironment envRTL = new STextEnvironment(null, false, STextEnvironment.ORIENT_RTL);
25		25
26	STextProcessor processor;	26	STextProcessor processor;
		27	STextHandler handler = new STextHandler(null);
27		28
28	private void doTest1(String msg, String data, String leanLTR, String fullLTR, int[] l2fMapLTR, int[] f2lMapLTR, String leanRTL, String fullRTL, int[] l2fMapRTL, int[] f2lMapRTL) {	29	private void doTest1(String msg, String data, String leanLTR, String fullLTR, int[] l2fMapLTR, int[] f2lMapLTR, String leanRTL, String fullRTL, int[] l2fMapRTL, int[] f2lMapRTL) {
29	String text, full, lean, label;	30	String text, full, lean, label;
30	int[] map;	31	int[] map;
31		32
32	text = toUT16(data);	33	text = toUT16(data);
33	lean = STextEngine.fullToLeanText(processor, envLTR, text, null);	34	lean = handler.fullToLeanText(envLTR, text);
34	assertEquals(msg + "LTR lean", leanLTR, toPseudo(lean));	35	assertEquals(msg + "LTR lean", leanLTR, toPseudo(lean));
35	full = STextEngine.leanToFullText(processor, envLTR, lean, null);	36	full = handler.leanToFullText(envLTR, lean);
36	assertEquals(msg + "LTR full", fullLTR, toPseudo(full));	37	assertEquals(msg + "LTR full", fullLTR, toPseudo(full));
37	map = STextEngine.leanToFullMap(processor, envLTR, lean, null);	38	map = handler.leanToFullMap(envLTR, lean);
38	label = msg + "leanToFullMap() LTR";	39	label = msg + "leanToFullMap() LTR";
39	assertEquals(label, array_display(l2fMapLTR), array_display(map));	40	assertEquals(label, array_display(l2fMapLTR), array_display(map));
40	map = STextEngine.fullToLeanMap(processor, envLTR, text, null);	41	map = handler.fullToLeanMap(envLTR, text);
41	label = msg + "fullToLeanMap() LTR";	42	label = msg + "fullToLeanMap() LTR";
42	assertEquals(label, array_display(f2lMapLTR), array_display(map));	43	assertEquals(label, array_display(f2lMapLTR), array_display(map));
43		44
44	lean = STextEngine.fullToLeanText(processor, envRTL, text, null);	45	lean = handler.fullToLeanText(envRTL, text);
45	assertEquals(msg + "RTL lean", leanRTL, toPseudo(lean));	46	assertEquals(msg + "RTL lean", leanRTL, toPseudo(lean));
46	full = STextEngine.leanToFullText(processor, envRTL, lean, null);	47	full = handler.leanToFullText(envRTL, lean);
47	assertEquals(msg + "RTL full", fullRTL, toPseudo(full));	48	assertEquals(msg + "RTL full", fullRTL, toPseudo(full));
48	map = STextEngine.leanToFullMap(processor, envRTL, lean, null);	49	map = handler.leanToFullMap(envRTL, lean);
49	label = msg + "leanToFullMap() RTL";	50	label = msg + "leanToFullMap() RTL";
50	assertEquals(label, array_display(l2fMapRTL), array_display(map));	51	assertEquals(label, array_display(l2fMapRTL), array_display(map));
51	map = STextEngine.fullToLeanMap(processor, envRTL, text, null);	52	map = handler.fullToLeanMap(envRTL, text);
52	label = msg + "fullToLeanMap() RTL";	53	label = msg + "fullToLeanMap() RTL";
53	assertEquals(label, array_display(f2lMapRTL), array_display(map));	54	assertEquals(label, array_display(f2lMapRTL), array_display(map));
54	}	55	}
55		56
56	private void doTest2(String msg) {	57	private void doTest2(String msg) {
57	String text, data, full, lean, model;	58	String text, data, full, lean, model;
58	int[] state = new int[1];	59	int state;
59	int state1, state2, state3;	60	int state1, state2, state3;
60		61
61	data = "update \"AB_CDE\" set \"COL1\"@='01', \"COL2\"@='02' /* GH IJK";	62	data = "update \"AB_CDE\" set \"COL1\"@='01', \"COL2\"@='02' /* GH IJK";
62	text = toUT16(data);	63	text = toUT16(data);
63	state[0] = -1;	64	state = -1;
64	lean = STextEngine.fullToLeanText(processor, envLTR, text, state);	65	handler.setState(state);
65	state1 = state[0];	66	lean = handler.fullToLeanText(envLTR, text);
		67	state1 = handler.getState();
66	model = "update \"AB_CDE\" set \"COL1\"='01', \"COL2\"='02' /* GH IJK";	68	model = "update \"AB_CDE\" set \"COL1\"='01', \"COL2\"='02' /* GH IJK";
67	assertEquals(msg + "LTR lean", model, toPseudo(lean));	69	assertEquals(msg + "LTR lean", model, toPseudo(lean));
68	state[0] = -1;	70	state = -1;
69	full = STextEngine.leanToFullText(processor, envLTR, lean, state);	71	handler.setState(state);
		72	full = handler.leanToFullText(envLTR, lean);
70	assertEquals(msg + "LTR full", data, toPseudo(full));	73	assertEquals(msg + "LTR full", data, toPseudo(full));
71	assertEquals(msg + "state from leanToFullText", state1, state[0]);	74	state = handler.getState();
		75	assertEquals(msg + "state from leanToFullText", state1, state);
72	data = "THIS IS A COMMENT LINE";	76	data = "THIS IS A COMMENT LINE";
73	text = toUT16(data);	77	text = toUT16(data);
74	state[0] = state1;	78	state = state1;
75	lean = STextEngine.fullToLeanText(processor, envLTR, text, state);	79	handler.setState(state);
76	state2 = state[0];	80	lean = handler.fullToLeanText(envLTR, text);
		81	state2 = handler.getState();
77	model = "THIS IS A COMMENT LINE";	82	model = "THIS IS A COMMENT LINE";
78	assertEquals(msg + "LTR lean2", model, toPseudo(lean));	83	assertEquals(msg + "LTR lean2", model, toPseudo(lean));
79	state[0] = state1;	84	state = state1;
80	full = STextEngine.leanToFullText(processor, envLTR, lean, state);	85	handler.setState(state);
		86	full = handler.leanToFullText(envLTR, lean);
		87	state = handler.getState();
81	assertEquals(msg + "LTR full2", data, toPseudo(full));	88	assertEquals(msg + "LTR full2", data, toPseudo(full));
82	assertEquals(msg + "state from leanToFullText2", state2, state[0]);	89	assertEquals(msg + "state from leanToFullText2", state2, state);
83	data = "SOME MORE */ where \"COL3\"@=123";	90	data = "SOME MORE */ where \"COL3\"@=123";
84	text = toUT16(data);	91	text = toUT16(data);
85	state[0] = state2;	92	state = state2;
86	lean = STextEngine.fullToLeanText(processor, envLTR, text, state);	93	handler.setState(state);
87	state3 = state[0];	94	lean = handler.fullToLeanText(envLTR, text);
		95	state3 = handler.getState();
88	model = "SOME MORE */ where \"COL3\"=123";	96	model = "SOME MORE */ where \"COL3\"=123";
89	assertEquals(msg + "LTR lean3", model, toPseudo(lean));	97	assertEquals(msg + "LTR lean3", model, toPseudo(lean));
90	state[0] = state2;	98	state = state2;
91	full = STextEngine.leanToFullText(processor, envLTR, lean, state);	99	handler.setState(state);
		100	full = handler.leanToFullText(envLTR, lean);
		101	state = handler.getState();
92	assertEquals(msg + "LTR full3", data, toPseudo(full));	102	assertEquals(msg + "LTR full3", data, toPseudo(full));
93	assertEquals(msg + "state from leanToFullText3", state3, state[0]);	103	assertEquals(msg + "state from leanToFullText3", state3, state);
94	}	104	}
95		105
96	public void testFullToLean() {	106	public void testFullToLean() {
97		107
98	processor = STextProcessorFactory.PROC_COMMA_DELIMITED;	108	processor = STextProcessorFactory.PROC_COMMA_DELIMITED;
		109	handler.setProcessor(processor);
99	doTest1("testFullToLean #1 - ", "", "", "", new int[0], new int[0], "", "", new int[0], new int[0]);	110	doTest1("testFullToLean #1 - ", "", "", "", new int[0], new int[0], "", "", new int[0], new int[0]);
100	int[] map1 = new int[] {0, 1, 2, 3, 4};	111	int[] map1 = new int[] {0, 1, 2, 3, 4};
101	int[] map2 = new int[] {2, 3, 4, 5, 6};	112	int[] map2 = new int[] {2, 3, 4, 5, 6};
Lines 243-248 Link Here
243		254
244	// test fullToLeanText with initial state	255	// test fullToLeanText with initial state
245	processor = STextProcessorFactory.PROC_SQL;	256	processor = STextProcessorFactory.PROC_SQL;
		257	handler.setProcessor(processor);
246	doTest2("testFullToLean #38 - ");	258	doTest2("testFullToLean #38 - ");
247	}	259	}
248	}	260	}

Lines 23-34 Link Here

(-)src/org/eclipse/equinox/bidi/internal/tests/STextMathTest.java (-2 / +3 lines)
23	static final STextEnvironment envRTL = new STextEnvironment("ar", false, STextEnvironment.ORIENT_RTL);	23	static final STextEnvironment envRTL = new STextEnvironment("ar", false, STextEnvironment.ORIENT_RTL);
24		24
25	STextProcessor processor = STextProcessorFactory.PROC_RTL_ARITHMETIC;	25	STextProcessor processor = STextProcessorFactory.PROC_RTL_ARITHMETIC;
		26	STextHandler handler = new STextHandler(processor);
26		27
27	private void verifyOneLine(String msg, String data, String resLTR, String resRTL) {	28	private void verifyOneLine(String msg, String data, String resLTR, String resRTL) {
28	String lean = toUT16(data);	29	String lean = toUT16(data);
29	String fullLTR = STextEngine.leanToFullText(processor, envLTR, lean, null);	30	String fullLTR = handler.leanToFullText(envLTR, lean);
30	assertEquals(msg + " LTR - ", resLTR, toPseudo(fullLTR));	31	assertEquals(msg + " LTR - ", resLTR, toPseudo(fullLTR));
31	String fullRTL = STextEngine.leanToFullText(processor, envRTL, lean, null);	32	String fullRTL = handler.leanToFullText(envRTL, lean);
32	assertEquals(msg + " RTL - ", resRTL, toPseudo(fullRTL));	33	assertEquals(msg + " RTL - ", resRTL, toPseudo(fullRTL));
33	}	34	}
34		35