thdltools/Jskad
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Jskad/source/org/thdl/tib/input/DuffPaneTest.java

395 lines
15 KiB
Java
Raw Normal View History

DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
/*
The contents of this file are subject to the THDL Open Community License
Version 1.0 (the "License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License on the THDL web site
(http://www.thdl.org/).
Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
License for the specific terms governing rights and limitations under the
License.
The Initial Developer of this software is the Tibetan and Himalayan Digital
Library (THDL). Portions created by the THDL are Copyright 2002-2003 THDL.
All Rights Reserved.
Contributor(s): ______________________________________.
*/
package org.thdl.tib.input;
import junit.framework.TestCase;
import javax.swing.Action;
import javax.swing.KeyStroke;
import org.thdl.util.ThdlOptions;
/**
* @author David Chandler
*
* Tests {@link org.thdl.tib.input.Duffpane} at the unit level to see
* that the various keyboards work as expected.
*/
brtan now gives TMW->Wylie brtan, not b.rtan. Etc. See bug report http://sourceforge.net/tracker/index.php?func=detail&aid=785791&group_id=61934&atid=502515.
2003-08-09 17:48:40 +00:00
// DLC NOW ask around -- does wylie have the ambiguity edge over ACIP because l+ta is not legal wylie (only lta is)?
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
public class DuffPaneTest extends TestCase {
/** A DuffPane that uses THDL's extended Wylie keyboard: */
private DuffPane dp;
/** Sets us up a DuffPane. */
protected void setUp() {
// We don't want to use options.txt:
ThdlOptions.forTestingOnlyInitializeWithoutDefaultOptionsFile();
getWylie now takes a parameter for error detection; I'm not detecting errors here though. Fixed a typo in a property name.
2003-07-01 23:20:08 +00:00
// We don't want to load the TM or TMW font files ourselves:
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ThdlOptions.setUserPreference("thdl.rely.on.system.tmw.fonts", true);
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
ThdlOptions.setUserPreference("thdl.rely.on.system.tm.fonts", true);
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ThdlOptions.setUserPreference("thdl.debug", true);
dp = new DuffPane();
dp.enableCaretManaging();
dp.registerKeyboard();
}
/** Tears us down a DuffPane. */
protected void tearDown() {
// let GC do its worst with dp. We're all set.
dp = null;
}
/**
* Plain vanilla constructor for DuffPaneTest.
* @param arg0
*/
public DuffPaneTest(String arg0) {
super(arg0);
}
/** Invokes a text UI and runs all this class's tests. */
public static void main(String[] args) {
junit.textui.TestRunner.run(DuffPaneTest.class);
}
/** After ensuring that the caret is at the very end of the
* DuffPane's text, and that nothing is selected, this tells the
* DuffPane that the user has pressed key. */
private void fireKeypressWithoutModifiers(char key) {
dp.performKeyStroke(0, new String(new char[] { key }));
}
private void fireKeysWithoutModifiers(String x) {
for (int i = 0; i < x.length(); i++) {
fireKeypressWithoutModifiers(x.charAt(i));
}
}
private void ensureKeysGiveCorrectWylie(String wylie) {
ensureKeysGiveCorrectWylie(wylie, wylie);
}
private void ensureKeysGiveCorrectWylie(String keys, String wylie) {
dp.newDocument(); // initialize to a blank canvas.
fireKeysWithoutModifiers(keys);
getWylie now takes a parameter for error detection; I'm not detecting errors here though. Fixed a typo in a property name.
2003-07-01 23:20:08 +00:00
boolean passes = wylie.equals(dp.getWylie(new boolean[] { false }));
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
if (!passes) {
System.out.println("Congrats! These keys, \"" + keys
getWylie now takes a parameter for error detection; I'm not detecting errors here though. Fixed a typo in a property name.
2003-07-01 23:20:08 +00:00
+ "\", give this wylie, \"" + dp.getWylie(new boolean[] { false })
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
+ "\", not the expected \"" + wylie + "\"");
}
assertTrue(passes);
}
We now produce EWTS m.ya, g.rwa, d.rwa, and b.ya during TMW->Wylie. Our disambiguation is now perfect, happening when and only when it is necessary. These are all illegal, so it shouldn't affect many existing conversions. But if there were typos, it could.
2003-08-10 18:46:01 +00:00
public void testDisambiguation() {
ensureKeysGiveCorrectWylie("gya");
ensureKeysGiveCorrectWylie("g.ya");
ensureKeysGiveCorrectWylie("bya");
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
ensureKeysGiveCorrectWylie("b.ya", "baya");
We now produce EWTS m.ya, g.rwa, d.rwa, and b.ya during TMW->Wylie. Our disambiguation is now perfect, happening when and only when it is necessary. These are all illegal, so it shouldn't affect many existing conversions. But if there were typos, it could.
2003-08-10 18:46:01 +00:00
ensureKeysGiveCorrectWylie("mya");
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
ensureKeysGiveCorrectWylie("m.ya", "maya");
ensureKeysGiveCorrectWylie("'ya", "'aya");
ensureKeysGiveCorrectWylie("'.ya", "'aya");
ensureKeysGiveCorrectWylie("dya",
"daya");
ensureKeysGiveCorrectWylie("d.ya",
"daya");
We now produce EWTS m.ya, g.rwa, d.rwa, and b.ya during TMW->Wylie. Our disambiguation is now perfect, happening when and only when it is necessary. These are all illegal, so it shouldn't affect many existing conversions. But if there were typos, it could.
2003-08-10 18:46:01 +00:00
ensureKeysGiveCorrectWylie("grwa");
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
ensureKeysGiveCorrectWylie("g.rwa",
"garwa");
We now produce EWTS m.ya, g.rwa, d.rwa, and b.ya during TMW->Wylie. Our disambiguation is now perfect, happening when and only when it is necessary. These are all illegal, so it shouldn't affect many existing conversions. But if there were typos, it could.
2003-08-10 18:46:01 +00:00
ensureKeysGiveCorrectWylie("gra");
ensureKeysGiveCorrectWylie("dra");
ensureKeysGiveCorrectWylie("drwa");
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
ensureKeysGiveCorrectWylie("d.rwa",
"darwa");
We now produce EWTS m.ya, g.rwa, d.rwa, and b.ya during TMW->Wylie. Our disambiguation is now perfect, happening when and only when it is necessary. These are all illegal, so it shouldn't affect many existing conversions. But if there were typos, it could.
2003-08-10 18:46:01 +00:00
ensureKeysGiveCorrectWylie("g.r", "gar");
ensureKeysGiveCorrectWylie("d.r", "dar");
ensureKeysGiveCorrectWylie("'.r", "'ar");
ensureKeysGiveCorrectWylie("b.r", "bar");
ensureKeysGiveCorrectWylie("m.r", "mar");
}
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
/** Tests performing a few keystrokes in the Extended Wylie
* keyboard, turning those into our internal representation (IR),
* and then converting the result to Extended Wylie. */
public void testWylieToIRToWylie() {
Added a test for ts.ha vs. tsha ambiguity; there is no ambiguity.
2003-07-18 03:51:29 +00:00
ensureKeysGiveCorrectWylie("ts.ha",
"tsaha");
ensureKeysGiveCorrectWylie("tsha");
ensureKeysGiveCorrectWylie("tsa");
More test cases related to the following: The Tibetan d.za was being converted into the Wylie dza incorrectly. This is a rare case, but I want TMW->Wylie to be perfectly unambiguous.
2003-07-18 02:31:02 +00:00
ensureKeysGiveCorrectWylie("t.sa",
"tas");
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
ensureKeysGiveCorrectWylie("d.za", "daza");
Added a test for ts.ha vs. tsha ambiguity; there is no ambiguity.
2003-07-18 03:51:29 +00:00
ensureKeysGiveCorrectWylie("dza");
More test cases related to the following: The Tibetan d.za was being converted into the Wylie dza incorrectly. This is a rare case, but I want TMW->Wylie to be perfectly unambiguous.
2003-07-18 02:31:02 +00:00
ensureKeysGiveCorrectWylie("s.ha",
"saha");
Added a test for ts.ha vs. tsha ambiguity; there is no ambiguity.
2003-07-18 03:51:29 +00:00
ensureKeysGiveCorrectWylie("sha");
More test cases related to the following: The Tibetan d.za was being converted into the Wylie dza incorrectly. This is a rare case, but I want TMW->Wylie to be perfectly unambiguous.
2003-07-18 02:31:02 +00:00
Jeff C. H. Wu found a bug whereby typing 'cuig' just after starting Jskad fails (by producing 'cug') although typing 'kcuig' succeeds. This is now fixed, and test cases now exist to ensure that the problem doesn't reappear.
2003-05-31 12:58:36 +00:00
ensureKeysGiveCorrectWylie("kue ");
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
ensureKeysGiveCorrectWylie("012345678901234 ");
David Chapman removed some lines from tibwn.ini. That breaks TM<->TMW mappings, so I've put them back, but with the EWTS non-correspondences \tmwXYYY. Jskad no longer supports superscribed or subscribed numerals, because EWTS does not.
2003-08-26 01:28:02 +00:00
if (false) {
// DLC FIXME: we can no longer express the super- and
// subscribed numerals. Not with \\u, \\nu, or regular
// Wylie.
ensureKeysGiveCorrectWylie("<8<7<0 ");
ensureKeysGiveCorrectWylie("ka<7 ",
"ka<7. ");
ensureKeysGiveCorrectWylie("ka <7 ");
ensureKeysGiveCorrectWylie("ka>7 ",
"ka>7. ");
ensureKeysGiveCorrectWylie("ka >7 ");
}
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
// DLC FIXME : M^ doesn't work. nga, na do, k,kh do, why not M, M^?
Jeff C. H. Wu found a bug whereby typing 'cuig' just after starting Jskad fails (by producing 'cug') although typing 'kcuig' succeeds. This is now fixed, and test cases now exist to ensure that the problem doesn't reappear.
2003-05-31 12:58:36 +00:00
ensureKeysGiveCorrectWylie("kuau ");
ensureKeysGiveCorrectWylie("ku-i ");
ensureKeysGiveCorrectWylie("kuai ");
ensureKeysGiveCorrectWylie("cuig ");
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
ensureKeysGiveCorrectWylie("kcuig ",
"kacuiga ");
ensureKeysGiveCorrectWylie("gcuig ");
ensureKeysGiveCorrectWylie("gcuigs'e'i'i'o'am'ang'e'o'u'am'am ");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("nga ");
Jeff C. H. Wu found a bug whereby typing 'cuig' just after starting Jskad fails (by producing 'cug') although typing 'kcuig' succeeds. This is now fixed, and test cases now exist to ensure that the problem doesn't reappear.
2003-05-31 12:58:36 +00:00
ensureKeysGiveCorrectWylie("nga /");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("nag");
ensureKeysGiveCorrectWylie("bkra shis bde legs/");
ensureKeysGiveCorrectWylie("bakra shisa bade legs/",
"bkra shis bde legs/");
ensureKeysGiveCorrectWylie("sgom pa'am ");
ensureKeysGiveCorrectWylie("sgom pe'am ");
ensureKeysGiveCorrectWylie("le'u'i'o");
ensureKeysGiveCorrectWylie("la'u'i'o");
ensureKeysGiveCorrectWylie("la'u'i'o/la'am/pa'ang/pa'am'ang/pe'ang");
ensureKeysGiveCorrectWylie("bskyar.d'am'ang");
ensureKeysGiveCorrectWylie("lar.d");
ensureKeysGiveCorrectWylie("lard",
"larda");
ensureKeysGiveCorrectWylie("lal.d");
ensureKeysGiveCorrectWylie("lald",
"lalda");
ensureKeysGiveCorrectWylie("las.d");
ensureKeysGiveCorrectWylie("lasd",
"lasda");
Prefix rules have changed. A few are gone; a few new ones are here. I've implemented here a list that Robert Chilton sent me in private correspondence. He doesn't describe it as definitive, but since it affects ACIP->Tibetan conversions, and it's the best I've got, here they are. There's still an optional warning about "Hey, prefix rules matter for this tsheg bar." I've left in a few rules that I didn't find on RC's list; I've asked him to look into these further.
2003-10-18 05:48:53 +00:00
ensureKeysGiveCorrectWylie("b.lar.d", "balarada");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("blar.d");
ensureKeysGiveCorrectWylie("blarad",
"blar.d");
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
ensureKeysGiveCorrectWylie("b.lard",
"balarda");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
Prefix rules have changed. A few are gone; a few new ones are here. I've implemented here a list that Robert Chilton sent me in private correspondence. He doesn't describe it as definitive, but since it affects ACIP->Tibetan conversions, and it's the best I've got, here they are. There's still an optional warning about "Hey, prefix rules matter for this tsheg bar." I've left in a few rules that I didn't find on RC's list; I've asked him to look into these further.
2003-10-18 05:48:53 +00:00
ensureKeysGiveCorrectWylie("b.lal.d", "balalada");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("blald",
"blalda");
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
ensureKeysGiveCorrectWylie("b.lald",
"balalda");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
Prefix rules have changed. A few are gone; a few new ones are here. I've implemented here a list that Robert Chilton sent me in private correspondence. He doesn't describe it as definitive, but since it affects ACIP->Tibetan conversions, and it's the best I've got, here they are. There's still an optional warning about "Hey, prefix rules matter for this tsheg bar." I've left in a few rules that I didn't find on RC's list; I've asked him to look into these further.
2003-10-18 05:48:53 +00:00
ensureKeysGiveCorrectWylie("b.las.d", "balasada");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("blasd",
"blasda");
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
ensureKeysGiveCorrectWylie("b.lasd",
"balasda");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
Prefix rules have changed. A few are gone; a few new ones are here. I've implemented here a list that Robert Chilton sent me in private correspondence. He doesn't describe it as definitive, but since it affects ACIP->Tibetan conversions, and it's the best I've got, here they are. There's still an optional warning about "Hey, prefix rules matter for this tsheg bar." I've left in a few rules that I didn't find on RC's list; I've asked him to look into these further.
2003-10-18 05:48:53 +00:00
ensureKeysGiveCorrectWylie("b.luHna", "baluHna");
brtan now gives TMW->Wylie brtan, not b.rtan. Etc. See bug report http://sourceforge.net/tracker/index.php?func=detail&aid=785791&group_id=61934&atid=502515.
2003-08-09 17:48:40 +00:00
Prefix rules have changed. A few are gone; a few new ones are here. I've implemented here a list that Robert Chilton sent me in private correspondence. He doesn't describe it as definitive, but since it affects ACIP->Tibetan conversions, and it's the best I've got, here they are. There's still an optional warning about "Hey, prefix rules matter for this tsheg bar." I've left in a few rules that I didn't find on RC's list; I've asked him to look into these further.
2003-10-18 05:48:53 +00:00
ensureKeysGiveCorrectWylie("b.lA-iMg", "balA-iMga");
brtan now gives TMW->Wylie brtan, not b.rtan. Etc. See bug report http://sourceforge.net/tracker/index.php?func=detail&aid=785791&group_id=61934&atid=502515.
2003-08-09 17:48:40 +00:00
ensureKeysGiveCorrectWylie("blA-iMg");
Prefix rules have changed. A few are gone; a few new ones are here. I've implemented here a list that Robert Chilton sent me in private correspondence. He doesn't describe it as definitive, but since it affects ACIP->Tibetan conversions, and it's the best I've got, here they are. There's still an optional warning about "Hey, prefix rules matter for this tsheg bar." I've left in a few rules that I didn't find on RC's list; I've asked him to look into these further.
2003-10-18 05:48:53 +00:00
ensureKeysGiveCorrectWylie("b.lag", "balaga");
Private correspondence with Robert Chilton led to me to add and remove a few prefix rules. BLC and BGL are here, BLK, BLG, BLNG, BLJ, BNG, BJ, BNY, BN, and BDZ are gone. Added a few new tests.
2003-10-25 21:40:21 +00:00
ensureKeysGiveCorrectWylie("blga", "balga");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("b.las",
"bals");
ensureKeysGiveCorrectWylie("bl.s",
"blas");
ensureKeysGiveCorrectWylie("bls",
"bals");
Prefix rules have changed. A few are gone; a few new ones are here. I've implemented here a list that Robert Chilton sent me in private correspondence. He doesn't describe it as definitive, but since it affects ACIP->Tibetan conversions, and it's the best I've got, here they are. There's still an optional warning about "Hey, prefix rules matter for this tsheg bar." I've left in a few rules that I didn't find on RC's list; I've asked him to look into these further.
2003-10-18 05:48:53 +00:00
ensureKeysGiveCorrectWylie("b.rag", "baraga");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("brg",
brtan now gives TMW->Wylie brtan, not b.rtan. Etc. See bug report http://sourceforge.net/tracker/index.php?func=detail&aid=785791&group_id=61934&atid=502515.
2003-08-09 17:48:40 +00:00
"brga");
ensureKeysGiveCorrectWylie("b.rtan", "brtan");
ensureKeysGiveCorrectWylie("brtan");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("bars");
ensureKeysGiveCorrectWylie("b.rs",
"bars");
ensureKeysGiveCorrectWylie("brs",
"bars");
ensureKeysGiveCorrectWylie("br.s",
"bras");
ensureKeysGiveCorrectWylie("bras");
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
ensureKeysGiveCorrectWylie("d.wa",
"dawa");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("dawa",
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
"dawa");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("dwa");
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
ensureKeysGiveCorrectWylie("g.wa",
"gawa");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("gawa",
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
"gawa");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("gwa");
ensureKeysGiveCorrectWylie("'.wa",
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
"'awa");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("'awa",
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
"'awa");
ensureKeysGiveCorrectWylie("'wa",
"'awa");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("gyg",
"g.yag");
Tests disambiguation in TMW->Wylie conversion.
2003-07-14 12:21:02 +00:00
ensureKeysGiveCorrectWylie("gyug",
"gyug");
ensureKeysGiveCorrectWylie("gayug",
"g.yug");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("g.yag");
ensureKeysGiveCorrectWylie("gyag");
ensureKeysGiveCorrectWylie("gy.g",
"gyag");
ensureKeysGiveCorrectWylie("gys",
"g.yas");
ensureKeysGiveCorrectWylie("g.yas");
ensureKeysGiveCorrectWylie("gyas");
ensureKeysGiveCorrectWylie("gy.s",
"gyas");
// FIXME: shouldn't this give the four-glyph combo m-a-a-s?
ensureKeysGiveCorrectWylie("ma.a.asa",
"mas");
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
ensureKeysGiveCorrectWylie("'ka",
"'aka");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("'gas");
ensureKeysGiveCorrectWylie("gangs");
ensureKeysGiveCorrectWylie("gnags");
ensureKeysGiveCorrectWylie("'angs");
ensureKeysGiveCorrectWylie("'ag");
ensureKeysGiveCorrectWylie("'byung");
ensureKeysGiveCorrectWylie("'byungs");
Prefix rules have changed. A few are gone; a few new ones are here. I've implemented here a list that Robert Chilton sent me in private correspondence. He doesn't describe it as definitive, but since it affects ACIP->Tibetan conversions, and it's the best I've got, here they are. There's still an optional warning about "Hey, prefix rules matter for this tsheg bar." I've left in a few rules that I didn't find on RC's list; I've asked him to look into these further.
2003-10-18 05:48:53 +00:00
ensureKeysGiveCorrectWylie("b.lags", "balagasa");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("blags");
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
// DLC FIXME: add b-r-g-s, b-l-g-s, etc.
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("mngas",
"mangs");
ensureKeysGiveCorrectWylie("mangs");
ensureKeysGiveCorrectWylie("mn.gs",
"mnags");
ensureKeysGiveCorrectWylie("mnags");
ensureKeysGiveCorrectWylie("lmn.g",
"lamanaga");
ensureKeysGiveCorrectWylie("l.m.ng",
"lamanga");
ensureKeysGiveCorrectWylie("b.m.ng",
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
"bamanga");
ensureKeysGiveCorrectWylie("bmang",
"bamanga");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("gdams");
ensureKeysGiveCorrectWylie("g.d.m.s.",
"gdams");
ensureKeysGiveCorrectWylie("'gams");
ensureKeysGiveCorrectWylie("'.g.m.s",
"'gams");
{
// These are correctly handled in terms of
// makeIllegalTibetanGoEndToEnd:
ensureKeysGiveCorrectWylie("skalazasa");
ensureKeysGiveCorrectWylie("jskad",
"jaskada");
ensureKeysGiveCorrectWylie("jeskad",
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
"jeskada");
ensureKeysGiveCorrectWylie("jeskd",
"jesakada");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
ensureKeysGiveCorrectWylie("jesakada",
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
"jesakada");
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
}
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
{
// DLC FIXME: ai gives a.ai, a.i is required to get ai.
// DLC FIXME: haaa doesn't get you h.a., neither does
// ha.a; achen is tough to get.
}
ensureKeysGiveCorrectWylie("heM hiM h-iM heM haiM hoM hauM hUM ");
ensureKeysGiveCorrectWylie("hi.M ho.M he.M hu.M",
"hiM hoM heM huM");
brtan now gives TMW->Wylie brtan, not b.rtan. Etc. See bug report http://sourceforge.net/tracker/index.php?func=detail&aid=785791&group_id=61934&atid=502515.
2003-08-09 17:48:40 +00:00
ensureKeysGiveCorrectWylie("brgwU-imd");
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
ensureKeysGiveCorrectWylie("pad+me");
ensureKeysGiveCorrectWylie("pad+men+b+h+yuM");
ensureKeysGiveCorrectWylie("bskyUMbs");
ensureKeysGiveCorrectWylie("bskyUMbsHgro ");
Jskad's converter now has ACIP-to-Unicode built in. There are known bugs; it is pre-alpha. It's usable, though, and finds tons of errors in ACIP input files, with the user deciding just how pedantic to be. The biggest outstanding bug is the silent one: treating { }, space, as tsheg instead of whitespace when we ought to know better.
2003-08-24 06:40:53 +00:00
ensureKeysGiveCorrectWylie("gyurd", "gyurda");
ensureKeysGiveCorrectWylie("gyur.d");
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
ensureKeysGiveCorrectWylie("favakakhagangacachajanyatathadanapaphabamatsatshadzawazhaza'ayaralashasahaTaThaDaNaSha");
ensureKeysGiveCorrectWylie("fevekekhegengecechejenyetethedenepephebemetsetshedzewezheze'eyerelesheseheTeTheDeNeShe");
ensureKeysGiveCorrectWylie("fuvukukhugungucuchujunyututhudunupuphubumutsutshudzuwuzhuzu'uyurulushusuhuTuThuDuNuShu");
ensureKeysGiveCorrectWylie("fovokokhogongocochojonyotothodonopophobomotsotshodzowozhozo'oyoroloshosohoToThoDoNoSho");
ensureKeysGiveCorrectWylie("faivaikaikhaigaingaicaichaijainyaitaithaidainaipaiphaibaimaitsaitshaidzaiwaizhaizai'aiyairailaishaisaihaiTaiThaiDaiNaiShai");
ensureKeysGiveCorrectWylie("fauvaukaukhaugaungaucauchaujaunyautauthaudaunaupauphaubaumautsautshaudzauwauzhauzau'auyauraulaushausauhauTauThauDauNauShau");
ensureKeysGiveCorrectWylie("fivikikhigingicichijinyitithidinipiphibimitsitshidziwizhizi'iyirilishisihiTiThiDiNiShi");
ensureKeysGiveCorrectWylie("don't touch my coffee/that makes me very angry/supersize my drink",
TMW->Wylie conversion now takes advantage of prefix rules, the rules that say "ya can take a ga prefix" etc. The ACIP->Unicode converter now gives warnings (optionally, and by default, inline). This converter now produces output even when lexical errors occur, but the output has errors and warnings inline.
2003-08-23 22:03:37 +00:00
"dona'ata tocha mya cofafe/thata makesa me veraya angaraya/superasize mya drinaka");
Jskad supports <7, >8, etc. again; it no longer supports the punctuation '<' and '>'. The current keyboard implementation makes this an either-or proposition, when fundamentally it need not be. Added a <?Numbers?> command and an <?Input:Numbers?> command to tibwn.ini; broke the numbers apart from the consonants. This facilitates the new-and-improved Tibetan->Wylie conversion. Tibetan->Wylie is now done by forming legal tsheg-bars. A legal tsheg bar is converted into perfect THDL Wylie. See code comments to learn what it thinks is a legal tsheg-bar, but it inlcudes bskyUMbsH minus the trailing punctuation (H), e.g. Illegal sequences, such as runs of transliterated Sanskrit, are turned into unambiguous Wylie; each glyph is followed by a vowel or a disambiguator ('.'). I've made it so that the illegal sequences are as beautiful as possible. You get 'pad+me', for example, not the equivalent but uglier 'pad+m.e.'.
2003-07-08 14:30:17 +00:00
DuffPane now has the start of a unit test suite. Invoke it via 'ant clean check'. Right now there are tests to ensure that typing certain sequences of keys in the Extended Wylie keyboard gives the expected Extended Wylie back when "Tools/Convert Tibetan to Wylie" is invoked. The syntactically illegal d.wa now converts to Tibetan and then back to d.wa (not dwa, as it did); likewise with the illegal g.wa. wa doesn't take any prefixes, but I prefer clean end-to-end behavior. (jeskd doesn't go end-to-end, though.) Note that you cannot successfully run the DuffPane tests on a Linux box unless your DISPLAY variable is set correctly. Thus, my nightly builds will fail with an Error (as opposed to a Failure).
2003-04-14 05:22:27 +00:00
}
}
Reference in a new issue Copy permalink