file_name
stringlengths 6
86
| file_path
stringlengths 45
249
| content
stringlengths 47
6.26M
| file_size
int64 47
6.26M
| language
stringclasses 1
value | extension
stringclasses 1
value | repo_name
stringclasses 767
values | repo_stars
int64 8
14.4k
| repo_forks
int64 0
1.17k
| repo_open_issues
int64 0
788
| repo_created_at
stringclasses 767
values | repo_pushed_at
stringclasses 767
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
TerminologyPanelView.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/views/TerminologyPanelView.java | package net.heartsome.cat.ts.test.ui.views;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarButton;
/**
* 视图：术语面板，单例模式
* @author felix_lu
* @version
* @since JDK1.6
*/
public final class TerminologyPanelView extends SWTBotView {
private static TerminologyPanelView view;
/**
* 按名称查找视图
*/
private TerminologyPanelView() {
super(HSBot.bot().viewByTitle(TsUIConstants.getString("viewTitleTerminologyPanel")).getReference(), HSBot.bot());
}
/**
* @return 术语视图实例;
*/
public static TerminologyPanelView getInstance() {
if (view == null) {
view = new TerminologyPanelView();
}
return view;
}
/**
* @return 工具栏按钮：插入术语;
*/
public SWTBotToolbarButton tlbBtnInsertTerm() {
return toolbarButton(TsUIConstants.getString("tlbBtnInsertTerm"));
}
// TODO 待实现
}
| 1,047 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
QuickTranslationPanelView.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/views/QuickTranslationPanelView.java | package net.heartsome.cat.ts.test.ui.views;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarButton;
/**
* 视图：快速翻译面板，单例模式
* @author felix_lu
* @version
* @since JDK1.6
*/
public final class QuickTranslationPanelView extends SWTBotView {
private static QuickTranslationPanelView view;
/**
* 按名称查找视图
*/
private QuickTranslationPanelView() {
super(HSBot.bot().viewByTitle(TsUIConstants.getString("viewTitleQuickTranslationPanel")).getReference(), HSBot
.bot());
}
/**
* @return 快速翻译视图实例;
*/
public static QuickTranslationPanelView getInstance() {
if (view == null) {
view = new QuickTranslationPanelView();
}
return view;
}
/* 按钮 */
/**
* @return 工具栏按钮：接受匹配;
*/
public SWTBotToolbarButton tlbBtnAcceptMatch() {
return toolbarButton(TsUIConstants.getString("tlbBtnAcceptMatch"));
}
/**
* @return 工具栏按钮：仅接受文本;
*/
public SWTBotToolbarButton tlbBtnAcceptTextOnly() {
return toolbarButton(TsUIConstants.getString("tlbBtnAcceptTextOnly"));
}
// TODO 待实现
}
| 1,299 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ProjectTreeView.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/views/ProjectTreeView.java | package net.heartsome.cat.ts.test.ui.views;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.waits.IsEditorOpened;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotEditor;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotMenu;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
/**
* 视图：项目树，单例模式
* @author felix_lu
* @version
* @since JDK1.6
*/
public final class ProjectTreeView extends SWTBotView {
private static SWTBotTree tree;
private static ProjectTreeView view;
/**
* 按名称查找视图
*/
private ProjectTreeView() {
super(HSBot.bot().viewByTitle(TsUIConstants.getString("viewTitleProjectTree")).getReference(), HSBot.bot());
}
/**
* 得到项目树所在的视图
* @return TSProjectTreeView 项目树所在的视图
*/
public static ProjectTreeView getInstance() {
if (view == null) {
view = new ProjectTreeView();
}
if (tree == null) {
tree = view.bot().tree();
}
return view;
}
/**
* 从视图中得到项目树
* @return SWTBotTree 项目树
*/
public static SWTBotTree getTree() {
if (tree == null) {
getInstance();
}
return tree;
}
/**
* @return 右键菜单：新建项目;
*/
public SWTBotMenu ctxMenuNewProject() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuNewProject"));
}
/**
* @return 右键菜单：新建其他;
*/
public SWTBotMenu ctxMenuNewOther() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuNewOther"));
}
/**
* @return 右键菜单：打开项目文件
*/
public SWTBotMenu ctxMenuOpenProjectFiles() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuOpenProjectFiles"));
}
/**
* @return 右键菜单：打开文件
*/
public SWTBotMenu ctxMenuOpenFile() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuOpenFile"));
}
/**
* @return 右键菜单：复制
*/
public SWTBotMenu ctxMenuCopy() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuCopy"));
}
/**
* @return 右键菜单：粘贴
*/
public SWTBotMenu ctxMenuPaste() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuPaste"));
}
/**
* @return 右键菜单：删除
*/
public SWTBotMenu ctxMenuDelete() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuDelete"));
}
/**
* @return 右键菜单：移动
*/
public SWTBotMenu ctxMenuMove() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuMove"));
}
/**
* @return 右键菜单：重命名
*/
public SWTBotMenu ctxMenuRename() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuRename"));
}
/**
* @return 右键菜单：刷新;
*/
public SWTBotMenu ctxMenuRefresh() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuRefresh"));
}
/**
* @return 右键菜单：关闭项目;
*/
public SWTBotMenu ctxMenuCloseProject() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuCloseProject"));
}
/**
* @return 右键菜单：关闭无关项目;
*/
public SWTBotMenu ctxMenuCloseUnrelatedProjects() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuCloseUnrelatedProjects"));
}
/**
* @return 右键菜单：分割 XLIFF 文件;
*/
public SWTBotMenu ctxMenuSplitXLIFF() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuSplitXLIFF"));
}
/**
* @return 右键菜单：合并 XLIFF 文件;
*/
public SWTBotMenu ctxMenuMergeXLIFF() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuMergeXLIFF"));
}
/**
* @return 右键菜单：预翻译;
*/
public SWTBotMenu ctxMenuPreTranslate() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuPreTranslate"));
}
/**
* @return 右键菜单：品质检查;
*/
public SWTBotMenu ctxMenuQACheck() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuQACheck"));
}
/**
* @return 右键菜单：项目设置;
*/
public SWTBotMenu ctxMenuProjectSetting() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuProjectSetting"));
}
/**
* @return 右键菜单：将源文件转换为 XLIFF 文件
*/
public SWTBotMenu ctxMenuConvertSrcFile2Xliff() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuConvertSrcFile2Xliff"));
}
/**
* @return 右键菜单：将 XLIFF 文件转换为目标文件
*/
public SWTBotMenu ctxMenuConvertXliffFile2Tgt() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuConvertXliffFile2Tgt"));
}
/**
* @return 右键菜单：属性;
*/
public SWTBotMenu ctxMenuProperties() {
return tree.contextMenu(TsUIConstants.getString("ctxMenuProperties"));
}
/* ****** 鼠标双击功能 ****** */
/**
* 双击打开 XLIFF 文件
* @param prjName
* XLIFF 文件所在的项目名称
* @param xlfFileName
* 要打开的 XLIFF 文件名称
*/
public static void doubleClickXlfFile(String prjName, final String xlfFileName) {
getTree().expandNode(prjName).expandNode("XLIFF").expandNode(xlfFileName).doubleClick();
// 确认文件被打开
SWTBotEditor editor = HSBot.bot().editorByTitle(xlfFileName);
HSBot.bot().waitUntil(new IsEditorOpened(editor));
}
}
| 5,272 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
NotesView.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/views/NotesView.java | package net.heartsome.cat.ts.test.ui.views;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTabItem;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarButton;
/**
* 视图：批注，单例模式
* @author felix_lu
* @version
* @since JDK1.6
*/
public final class NotesView extends SWTBotView {
private SWTBot viewBot = this.bot();
private static NotesView view;
/**
* 按名称查找视图
*/
private NotesView() {
super(HSBot.bot().viewByTitle(
TsUIConstants.getString("viewTitleNotes")).getReference(), HSBot.bot());
}
/**
* @return 批注视图实例;
*/
public static NotesView getInstance() {
if (view == null) {
view = new NotesView();
}
return view;
}
/**
* @return 工具栏按钮：添加批注;
*/
public SWTBotToolbarButton tlbBtnAddNote() {
return toolbarButton(TsUIConstants.getString("tlbBtnAddNote"));
}
/**
* @return 工具栏按钮：编辑批注;
*/
public SWTBotToolbarButton tlbBtnEditNote() {
return toolbarButton(TsUIConstants.getString("tlbBtnEditNote"));
}
/**
* @return 工具栏按钮：删除批注;
*/
public SWTBotToolbarButton tlbBtnDeleteNote() {
return toolbarButton(TsUIConstants.getString("tlbBtnDeleteNote"));
}
/**
* @return 选项卡：批注;
*/
public SWTBotTabItem tabNote() {
return viewBot.tabItem();
}
/**
* @param noteIndex
* @return 选项卡：指定序号的批注;
*/
public SWTBotTabItem tabNote(int noteIndex) {
return viewBot.tabItem(noteIndex);
}
/**
* @param noteTitle
* @return 选项卡：指定标题的批注;
*/
public SWTBotTabItem tabNote(String noteTitle) {
return viewBot.tabItem(noteTitle);
}
}
| 1,902 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
XliffUtil.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/utils/XliffUtil.java | package net.heartsome.cat.ts.test.ui.utils;
import java.util.ArrayList;
import java.util.List;
import net.heartsome.cat.common.innertag.TagStyle;
import net.heartsome.cat.common.ui.utils.InnerTagUtil;
import net.heartsome.cat.ts.core.file.RowIdUtil;
import net.heartsome.xml.vtdimpl.VTDUtils;
import com.ximpleware.AutoPilot;
import com.ximpleware.NavException;
import com.ximpleware.VTDGen;
import com.ximpleware.VTDNav;
import com.ximpleware.XPathEvalException;
import com.ximpleware.XPathParseException;
/**
* 通过文本段的 RowID 在对应的 XLIFF 文件中读取相关内容。<br/>
* 使用了 HSCAT8 项目中的 net.heartsome.cat.ts.core.file.RowIdUtil 和 net.heartsome.xml.vtdimpl.VTDUtils 两个类。
* @author felix_lu
*/
public class XliffUtil {
private VTDGen vg;
private VTDUtils vu;
private String rowID;
private String xlfFile;
private String fileXPath;
private String tuid;
/**
* 直接通过 RowID 来定位，适用于最常见的在界面 NatTable 中显示的文本段。
* @param rowID
*/
public XliffUtil(String rowID) {
this.rowID = rowID;
this.xlfFile = RowIdUtil.getFileNameByRowId(rowID);
this.fileXPath = RowIdUtil.getFileXpathByRowId(rowID);
this.tuid = RowIdUtil.getTUIdByRowId(rowID);
this.vg = new VTDGen();
if (vg.parseFile(xlfFile, true)) {
VTDNav vn = vg.getNav();
try {
vu = new VTDUtils(vn);
} catch (NavException e) {
e.printStackTrace();
}
}
}
/**
* 通过可组成 RowID 的三个参数来定位，适用于不在界面 NatTable 中显示的文本段， 如合并后变为空的 trans-unit 节点。
* @param xlfFile
* XLIFF 文件路径
* @param originalFile
* 源文件路径，建议从相邻文本段中用本类方法获取
* @param tuid
* 翻译单元 ID
*/
public XliffUtil(String xlfFile, String originalFile, String tuid) {
this.xlfFile = xlfFile;
this.fileXPath = "/xliff/file[@original=\"" + originalFile + "\"]";
this.tuid = tuid;
this.rowID = RowIdUtil.getRowId(xlfFile, originalFile, tuid);
this.vg = new VTDGen();
if (vg.parseFile(xlfFile, true)) {
VTDNav vn = vg.getNav();
try {
vu = new VTDUtils(vn);
} catch (NavException e) {
e.printStackTrace();
}
}
}
/* ******** Getter ******** */
/**
* @return ;
*/
public String getXlfFile() {
return xlfFile;
}
/**
* @return ;
*/
public String getFileXPath() {
return fileXPath;
}
/**
* @return String 当前实例的 tuid 成员变量值<br/>
* <b>请注意</b>：该值可能和 XLIFF 文件中的实际值不一致，若要获得文件中的属性值，应使用 getAttributeOfTU() 方法
*/
public String getTUID() {
return tuid;
}
/**
* @return ;
*/
public String getRowID() {
return rowID;
}
/* * 一些与 rowID 无关的静态方法 * */
/**
* @param xlfFile
* XLIFF 文件路径
* @return VTDUtils
*/
public static VTDUtils getVU(String xlfFile) {
VTDGen vg = new VTDGen();
if (vg.parseFile(xlfFile, true)) {
VTDNav vn = vg.getNav();
try {
return new VTDUtils(vn);
} catch (NavException e) {
e.printStackTrace();
}
}
return null;
}
/**
* @param xlfFile
* XLIFF 文件路径
* @return List<String> <file> 节点 original 属性值所组成的 List
*/
public static List<String> getOriginalFiles(String xlfFile) {
return getOriginalFiles(getVU(xlfFile));
}
/**
* @param vu
* XLIFF 文件对应的 VTDUtils
* @return List<String>
*/
public static List<String> getOriginalFiles(VTDUtils vu) {
ArrayList<String> list = new ArrayList<String>();
String xpath = "/xliff/file";
AutoPilot ap = new AutoPilot(vu.getVTDNav());
try {
ap.selectXPath(xpath);
while (ap.evalXPath() != -1) {
list.add(vu.getElementAttribute(".", "original"));
}
} catch (XPathParseException e) {
e.printStackTrace();
} catch (XPathEvalException e) {
e.printStackTrace();
} catch (NavException e) {
e.printStackTrace();
}
return list;
}
/**
* @param xlfFile
* XLIFF 文件路径
* @return int <file> 节点的数量，即源文件数量
*/
public static int fileCount(String xlfFile) {
return getOriginalFiles(xlfFile).size();
}
/**
* @param xlfFile
* @param includingNull
* 是否包括空节点
* @return int trans-unit 节点数量，包括空节点
*/
public static int tuCount(String xlfFile, boolean includingNull) {
String xpath = "/xliff/file";
return tuCountOfFile(xlfFile, xpath, includingNull);
}
/**
* @param xlfFile
* @param fileXPath
* @param includingNull
* 是否包括空节点
* @return int 指定 file 节点下的 trans-unit 节点数量
*/
public static int tuCountOfFile(String xlfFile, String filePath, boolean includingNull) {
VTDUtils vu = getVU(xlfFile);
if (includingNull) {
String xpath = "/xliff/file[@original=\"" + filePath + "\"]/body//trans-unit";
return vu.getValues(xpath).size(); // 包括空节点
} else {
int count = 0;
String xpath = "/xliff/file[@original=\"" + filePath + "\"]/body//trans-unit/source/text()";
List<String> srcTexts = vu.getValues(xpath);
for (String srcText : srcTexts) {
if (srcText != null && !srcText.equals("")) {
count++; // 不含空节点
}
}
return count;
}
}
/**
* @param xlfFile
* @param srcLang
* @param tgtLang
* @param includingNull
* @return int 指定语言对的 trans-unit 节点数量，以 file 节点的源、目标语言为准
*/
public static int tuCountOfLangPair(String xlfFile, String srcLang, String tgtLang, boolean includingNull) {
VTDUtils vu = getVU(xlfFile);
List<String> orgFiles = getOriginalFiles(vu);
int tuCount = 0;
for (String orgFile : orgFiles) {
String[] langPair = getLangPairOfFile(xlfFile, orgFile);
if (srcLang.equals(langPair[0]) && tgtLang.equals(langPair[1])) {
int count = tuCountOfFile(xlfFile, orgFile, includingNull);
tuCount += count;
}
}
return tuCount;
}
/**
* @param xlfFile
* @param filePath
* @return String[] 第一个元素为源语言，第二个为目标语言
*/
public static String[] getLangPairOfFile(String xlfFile, String filePath) {
VTDUtils vu = getVU(xlfFile);
String xpath = "/xliff/file[@original=\"" + filePath + "\"]";
String[] langPair = new String[2];
try {
langPair[0] = vu.getElementAttribute(xpath, "source-language");
langPair[1] = vu.getElementAttribute(xpath, "target-language");
} catch (XPathParseException e) {
e.printStackTrace();
} catch (XPathEvalException e) {
e.printStackTrace();
} catch (NavException e) {
e.printStackTrace();
}
return langPair;
}
/**
* @param xlfFile
* @return List<String[]> 由源、目标语言数组组成的 List
*/
public static List<String[]> getAllLangPairs(String xlfFile) {
ArrayList<String[]> langPairs = new ArrayList<String[]>();
List<String> orgFiles = getOriginalFiles(xlfFile);
for (String orgFile : orgFiles) { // 查找每个 <file> 节点的源、目标语言
String[] langPair = getLangPairOfFile(xlfFile, orgFile);
if (langPairs.size() == 0) { // 若 List 为空，直接添加
langPairs.add(langPair);
} else {
boolean noRepeat = false;
for (String[] langP : langPairs) { // 对比 List 中已有的每个语言对
if (langP[0].equals(langPair[0]) && langP[1].equals(langPair[1])) {
noRepeat = false; // 只要 List 中已有相同的语言对，就标记为重复（可能在上一轮循环中认为无重复）
break; // 并跳出循环
} else {
noRepeat = true;
}
}
if (noRepeat) { // 只有在对比过 List 中所有语言对之后，noRepeat 仍为 true，才能确认该语言对没有重复
langPairs.add(langPair);
}
}
}
return langPairs;
}
/**
* @param text
* 纯文本
* @return String 简单标记形式显示的文本
*/
public static String tagged(String text) {
StringBuffer t = new StringBuffer(text);
InnerTagUtil.parseXmlToDisplayValue(t, TagStyle.getDefault()); // TODO: 需要修改相关代码，使之支持不同的标记样式，而不只是默认的
return t.toString();
}
/* ******** <file> 节点相关内容 ******** */
/**
* @return String 源文件路径，从 <file> 节点的 XPath 中截取
*/
public String getOriginalFile() {
int fromIndex = fileXPath.indexOf("\"") + 1;
int toIndex = fileXPath.indexOf("\"", fromIndex);
return fileXPath.substring(fromIndex, toIndex);
}
/**
* @param attribute
* 属性名称，可以为：original source-language datatype tool tool-id date xml:space ts category target-language
* product-name product-version build-num
* @return String 属性值
*/
public String getAttributeOfFile(String attribute) {
String xpath = RowIdUtil.getFileXpathByRowId(rowID);
try {
return vu.getElementAttribute(xpath, attribute);
} catch (XPathParseException e) {
e.printStackTrace();
} catch (XPathEvalException e) {
e.printStackTrace();
} catch (NavException e) {
e.printStackTrace();
}
return null;
}
/**
* @return List<String> 当前 XLIFF 文件中所有 <file> 节点的 original 属性
*/
public List<String> getOriginalFiles() {
return getOriginalFiles(vu);
}
/**
* @return String <file> 节点中的源语言属性值
*/
public String getSourceLangOfFile() {
return getAttributeOfFile("source-language");
}
/**
* @return String <file> 节点中的目标语言属性值;
*/
public String getTargetLangOfFile() {
return getAttributeOfFile("target-language");
}
/**
* @return boolean True 表示骨架内嵌
*/
public boolean isSkeletonEmbed() {
String xpath = fileXPath + "/header/skl/internal-file";
return vu.pilot(xpath) != -1;
}
/**
* @return String 骨架文件路径
*/
public String getSkeletonPath() {
if (isSkeletonEmbed()) {
return null;
} else {
String xpath = fileXPath + "/header/skl/external-file";
try {
return vu.getElementAttribute(xpath, "href");
} catch (XPathParseException e) {
e.printStackTrace();
} catch (XPathEvalException e) {
e.printStackTrace();
} catch (NavException e) {
e.printStackTrace();
}
return null;
}
}
/* ******** <trans-unit> 节点相关内容 ******** */
/**
* @param attribute
* trans-unit 属性名称，可以为：id approved translate reformat xml:space datatype ts phase-name restype resname
* extradata help-id menu menu-option menu-name coord font css-style style exstyle extype maxbytes
* minbytes size-unit maxheight minheight maxwidth minwidth charclass
* @return String 属性值
*/
public String getAttributeOfTU(String attribute) {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]";
try {
return vu.getElementAttribute(xpath, attribute);
} catch (XPathParseException e) {
e.printStackTrace();
} catch (XPathEvalException e) {
e.printStackTrace();
} catch (NavException e) {
e.printStackTrace();
}
return null;
}
/**
* @return boolean True 表示可翻译
*/
public boolean tuIsTranslatable() {
String value = getAttributeOfTU("translate");
return "yes".equals(value);
}
/**
* @return boolean True 表示已批准
*/
public boolean tuIsApproved() {
String value = getAttributeOfTU("approved");
return "yes".equals(value);
}
/**
* @return boolean True 可以编辑，即未批准、未锁定
*/
public boolean tuIsEditable() {
return tuIsTranslatable() && !tuIsApproved();
}
/**
* @return String size 单位
*/
public String getTUSizeUnit() {
return getAttributeOfTU("size-unit");
}
/**
* @return String 最大宽度，即最大字符长度
*/
public String getTUMaxWidth() {
return getAttributeOfTU("maxwidth");
}
/**
* @return String 最小宽度，即最少字符长度
*/
public String getTUMinWidth() {
return getAttributeOfTU("minwidth");
}
/**
* @return String 同一个 <file> 节点中下一个非空 trans-unit 节点的 tuid
*/
// public String tuidOfNextNotNullTU() {
// String nTUID;
// String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]";
// AutoPilot ap = new AutoPilot(vu.getVTDNav());
// try {
// ap.selectXPath(xpath);
//
// } catch (XPathParseException e) {
// e.printStackTrace();
// }
//
//
// return nTUID;
// }
/**
* @return XliffUtil XLIFF 文件中当前文本段的下一文本段对应的 XliffUtil 对象，若无则为 null
*/
public XliffUtil getNextXU() {
List<String> tuids = getAllTuIds();
int size = tuids.size();
int index = tuids.indexOf(tuid);
XliffUtil nextXU = null;
if (index < size - 1) {
int newIndex = index + 1;
nextXU = new XliffUtil(xlfFile, getOriginalFile(), tuids.get(newIndex));
}
return nextXU;
}
/**
* @return XliffUtil XLIFF 文件中当前文本段的下一非空文本段对应的 XliffUtil 对象， 若找到的文本段源文本内容为 null 或空字符串，则继续查找下一个，直到找到非空文本段或 到达 file
* 节点末尾为止，若未找到非空文本段则返回 null
*/
public XliffUtil getNextNotNullXU() {
XliffUtil nextXU = getNextXU();
if (nextXU != null) {
String nextSourceText = nextXU.getSourceText();
if (nextSourceText != null && !"".equals(nextSourceText)) {
return nextXU;
} else {
return nextXU.getNextNotNullXU();
}
} else {
return null;
}
}
/**
* @return XliffUtil XLIFF 文件中当前文本段的上一文本段对应的 XliffUtil 对象，若无则为 null
*/
public XliffUtil getPrevXU() {
List<String> tuids = getAllTuIds();
int index = tuids.indexOf(tuid);
XliffUtil prevXU = null;
if (index > 0) {
int newIndex = index - 1;
prevXU = new XliffUtil(xlfFile, getOriginalFile(), tuids.get(newIndex));
}
return prevXU;
}
/**
* @return XliffUtil XLIFF 文件中当前文本段的上一非空文本段对应的 XliffUtil 对象， 若找到的文本段源文本内容为 null 或空字符串，则继续查找上一个，直到找到非空文本段或 到达 file
* 节点起始位置为止，若未找到非空文本段则返回 null
*/
public XliffUtil getPrevNotNullXU() {
XliffUtil prevXU = getPrevXU();
if (prevXU != null) {
String prevSourceText = prevXU.getSourceText();
if (prevSourceText != null && !"".equals(prevSourceText)) {
return prevXU;
} else {
return prevXU.getPrevNotNullXU();
}
} else {
return null;
}
}
/**
* @return List<String> 包含当前 file 节点下所有 trans-unit 节点的 id 属性值
*/
public List<String> getAllTuIds() {
String xpath = fileXPath + "/body";
if (vu.pilot(xpath) != -1) {
return vu.getValues("descendant::trans-unit/@id");
// 不能直接用 /body//trans-unit 形式的 XPath，否则在有 group 节点时会打乱找到的trans-unit id 顺序
}
return null;
}
/* ******** <group> 节点相关内容 ******** */
/**
* @param attribute
* group 属性名称，可以为 id, datatype, xml:space, ts, restype, resname, extradata, help-id, menu, menu-option,
* menu-name, coord, font, css-style, style, exstyle, extype, translate, reformat, maxbytes, minbytes,
* size-unit, maxheight, minheight, maxwidth, minwidth, charclass, merged-trans
* @return String 属性值
*/
public String getAttributeOfGroup(String attribute) {
String tuXPath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]";
AutoPilot ap = new AutoPilot(vu.getVTDNav());
if (vu.pilot(ap, tuXPath) != -1) {
return vu.getValue(ap, "parent::group/@" + attribute);
}
return null;
}
/* ******** <source> <target> 节点相关内容 ******** */
/**
* @param attribute
* <source> 属性名称，可以为：xml:lang ts
* @return String 属性值
*/
public String getAttributeOfTUSource(String attribute) {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/source";
try {
return vu.getElementAttribute(xpath, attribute);
} catch (XPathParseException e) {
e.printStackTrace();
} catch (XPathEvalException e) {
e.printStackTrace();
} catch (NavException e) {
e.printStackTrace();
}
return null;
}
/**
* @param attribute
* <target> 属性名称，可以为：state state-qualifier phase-name xml:lang ts restype resname coord font
* css-style style exstyle equiv-trans
* @return String 属性值
*/
public String getAttributeOfTUTarget(String attribute) {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/target";
try {
return vu.getElementAttribute(xpath, attribute);
} catch (XPathParseException e) {
e.printStackTrace();
} catch (XPathEvalException e) {
e.printStackTrace();
} catch (NavException e) {
e.printStackTrace();
}
return null;
}
/**
* @param status
* 状态，可为 final, needs-adaptation, needs-l10n, needs-review-adaptation, needs-review-l10n,
* needs-review-translation, needs-translation, new, signed-off, translated
* @return boolean True 表示目标文本状态相符
*/
public boolean targetStatusIs(String status) {
String value = getAttributeOfTUTarget("state");
return (status == null && value == null || status.equals(value));
}
/**
* @return String 目标文本状态，无目标文本时为 null
*/
public String getTargetStatus() {
return getAttributeOfTUTarget("state");
}
/**
* @return String 源文本内容
*/
public String getSourceText() {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/source/text()";
return vu.getValue(xpath);
}
/**
* @return String 简单标记形式显示的源文本内容
*/
public String getSourceTextTagged() {
String text = getSourceText();
if (text == null) {
return null;
} else {
return tagged(text);
}
}
/**
* @return String 目标文本内容
*/
public String getTargetText() {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/target/text()";
return vu.getValue(xpath);
}
/**
* @return String 简单标记形式显示的目标文本内容
*/
public String getTargetTextTagged() {
String text = getTargetText();
if (text == null) {
return null;
} else {
return tagged(text);
}
}
/**
* @return String 源语言代码
*/
public String getTUSourceLang() {
return getAttributeOfTUSource("xml:lang");
}
/**
* @return String 目标语言代码
*/
public String getTUTargetLang() {
return getAttributeOfTUTarget("xml:lang");
}
/* ******** <alt-trans> 节点相关内容 ******** */
/**
* @param index
* alt-trans 索引号
* @param attribute
* 属性名称，可以为：mid match-quality tool tool-id crc xml:lang datatype xml:space ts restype resname extradata
* help-id menu menu-option menu-name coord font css-style style exstyle extype origin phase-name
* alttranstype
* @return String 属性值
*/
public String getAttributeOfAltTrans(int index, String attribute) {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/alt-trans[" + String.valueOf(index) + "]";
try {
return vu.getElementAttribute(xpath, attribute);
} catch (XPathParseException e) {
e.printStackTrace();
} catch (XPathEvalException e) {
e.printStackTrace();
} catch (NavException e) {
e.printStackTrace();
}
return null;
}
/**
* @param index
* <alt-trans> 索引号
* @return boolean True 表示该匹配来自 TM
*/
public boolean altTransIsTMMatch(int index) { // FIXME 实现已改，需要调整
return !"XLFEditor auto-Quick Translation".equals(getAltTransToolID(index))
&& !"Google Translate".equals(getAltTransOrigin(index))
&& !"style:ITALIC".equals(getAltTransFont(index));
}
/**
* @param index
* <alt-trans> 索引号
* @return boolean True 表示该匹配为快速翻译
*/
public boolean altTransIsQuickTranslation(int index) { // FIXME 实现已改，需要调整
return "XLFEditor auto-Quick Translation".equals(getAltTransToolID(index))
&& !"Google Translate".equals(getAltTransOrigin(index))
&& !"style:ITALIC".equals(getAltTransFont(index));
}
/**
* @param index
* <alt-trans> 索引号
* @return boolean True 表示该匹配为 Google 机器翻译
*/
public boolean altTransIsGoogleTranslation(int index) { // FIXME 实现已改，需要调整
return "XLFEditor auto-Quick Translation".equals(getAltTransToolID(index))
&& "Google Translate".equals(getAltTransOrigin(index)) && "style:ITALIC".equals(getAltTransFont(index));
}
/**
* @param index
* <alt-trans> 索引号
* @return String 匹配来源 origin 属性值
*/
public String getAltTransOrigin(int index) {
return getAttributeOfAltTrans(index, "origin");
}
/**
* @param index
* <alt-trans> 索引号
* @return String 工具 tool-id 属性值
*/
public String getAltTransToolID(int index) {
return getAttributeOfAltTrans(index, "tool-id");
}
/**
* @param index
* <alt-trans> 索引号
* @return String 字体 font 属性值
*/
public String getAltTransFont(int index) {
return getAttributeOfAltTrans(index, "font");
}
/**
* @param index
* <alt-trans> 索引号
* @return int 匹配率
*/
public int getAltTransMatchQuality(int index) {
String value = getAttributeOfAltTrans(index, "match-quality");
if (value.contains("%")) {
value = value.replace("%", "");
}
return Integer.valueOf(value);
}
/**
* @return int 不指定 <alt-trans> 索引号时，返回第一个匹配率
*/
public int getAltTransMatchQuality() {
return getAltTransMatchQuality(0);
}
/**
* @return List<String> 翻译匹配源文本
*/
public List<String> getAltTransSources() {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/alt-trans/source/text()";
return vu.getValues(xpath);
}
/**
* @param index
* <alt-trans> 索引号
* @return String <alt-trans> 源文本内容
*/
public String getAltTransSource(int index) {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/alt-trans[" + String.valueOf(index)
+ "]/source/text()";
return vu.getValue(xpath);
}
/**
* @return String 不指定索引号时，返回第一个 <alt-trans> 源文本内容
*/
public String getAltTransSource() {
return getAltTransSource(0);
}
/**
* @return List<String> 翻译匹配目标文本
*/
public List<String> getAltTransTargets() {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/alt-trans/target/text()";
return vu.getValues(xpath);
}
/**
* @param index
* <alt-trans> 索引号
* @return String <alt-trans> 目标文本内容
*/
public String getAltTransTarget(int index) {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/alt-trans[" + String.valueOf(index)
+ "]/target/text()";
return vu.getValue(xpath);
}
/**
* @return String 不指定索引号时，返回第一个 <alt-trans> 目标文本内容
*/
public String getAltTransTarget() {
return getAltTransTarget(0);
}
/**
* @param mq
* 匹配率
* @return List<String> 翻译匹配源文本
*/
public List<String> getAltTransSourcesByMatchQuality(int mq) {
String xpath1 = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/alt-trans[@match-quality=\""
+ String.valueOf(mq) + "\"]/source/text()";
String xpath2 = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/alt-trans[@match-quality=\""
+ String.valueOf(mq) + "%\"]/source/text()";
List<String> list = vu.getValues(xpath1);
if (list.size() != 0) {
return list;
} else {
return vu.getValues(xpath2);
}
}
/**
* @param mq
* 匹配率
* @return List<String> 翻译匹配目标文本
*/
public List<String> getAltTransTargetsByMatchQuality(int mq) {
String xpath1 = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/alt-trans[@match-quality=\""
+ String.valueOf(mq) + "\"]/target/text()";
String xpath2 = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/alt-trans[@match-quality=\""
+ String.valueOf(mq) + "%\"]/target/text()";
List<String> list = vu.getValues(xpath1);
if (list.size() != 0) {
return list;
} else {
return vu.getValues(xpath2);
}
}
/* ******** <note> 节点相关内容 ******** */
/**
* @return List<String> 所有 note 内容
*/
public List<String> getTUNotes() {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/note/text()";
return vu.getValues(xpath);
}
/**
* @param noteIndex
* note 索引
* @return String 指定索引号的 note 内容
*/
public String getTUNote(int noteIndex) {
String xpath = fileXPath + "/body//trans-unit[@id=\"" + tuid + "\"]/note[" + String.valueOf(noteIndex)
+ "]/text()";
return vu.getValue(xpath);
}
/**
* @return String 不指定 note 索引时，默认返回第一个 note 内容
*/
public String getTUNote() {
return getTUNote(0);
}
} | 25,437 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
IsSegmentSelected.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/waits/IsSegmentSelected.java | package net.heartsome.cat.ts.test.ui.waits;
import net.heartsome.cat.ts.test.ui.editors.XlfEditor;
import net.heartsome.test.swtbot.widgets.SWTBotNatTable;
import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
/**
* 判断编辑器的指定文本段是否被选中。
*/
public class IsSegmentSelected extends DefaultCondition {
private XlfEditor xlfEditor;
private SWTBotNatTable nattable;
private int targetRowIndex;
private int currentRowIndex;
/**
* @param xlfEditor
* @param targetRowIndex
*/
public IsSegmentSelected(XlfEditor xlfEditor, int targetRowIndex) {
this.xlfEditor = xlfEditor;
nattable = xlfEditor.nattable;
this.targetRowIndex = targetRowIndex;
}
/**
* (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#test()
*/
public boolean test() throws Exception {
currentRowIndex = nattable.indexOfSelectedRow(xlfEditor.positionOfTargetTextColumn());
return targetRowIndex == currentRowIndex;
}
/**
* (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#getFailureMessage()
*/
public String getFailureMessage() {
return "以下文本段未被选中：" + targetRowIndex;
}
}
| 1,175 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
IsProjectNotExist.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/waits/IsProjectNotExist.java | package net.heartsome.cat.ts.test.ui.waits;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 判断项目是否不在项目导航树上。
*/
public class IsProjectNotExist extends DefaultCondition {
private String projectName;
/**
* @param projectName
* 从项目树中查找匹配的项目名称。
*/
public IsProjectNotExist(String projectName) {
assertTrue("项目名称不能为空或 null。", (projectName != null && !"".equals(projectName)));
this.projectName = projectName;
}
/** (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#test()
*/
public boolean test() throws Exception {
boolean result = true;
SWTBotTreeItem[] items = ProjectTreeView.getTree().getAllItems();
for (SWTBotTreeItem item : items) {
if (projectName.equals(item.getText())) {
result = false;
break;
}
}
return result;
}
/** (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#getFailureMessage()
*/
public String getFailureMessage() {
return "仍可在项目导航树上找到项目：" + projectName;
}
}
| 1,278 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
IsProjectExist.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/waits/IsProjectExist.java | package net.heartsome.cat.ts.test.ui.waits;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 判断项目是否出现在项目导航树上。
*/
public class IsProjectExist extends DefaultCondition {
private String projectName;
/**
* 判断项目是否出现在项目导航树上。
* @param projectName
* 从项目树中查找匹配的项目名称。
*/
public IsProjectExist(String projectName) {
assertTrue("项目名称不能为空或 null。", (projectName != null && !"".equals(projectName)));
this.projectName = projectName;
}
/**
* (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#test()
*/
public boolean test() throws Exception {
boolean result = false;
SWTBotTreeItem[] items = ProjectTreeView.getTree().getAllItems();
for (SWTBotTreeItem item : items) {
if (projectName.equals(item.getText())) {
result = true;
break;
}
}
return result;
}
/**
* (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#getFailureMessage()
*/
public String getFailureMessage() {
return "未在项目导航树上找到项目：" + projectName;
}
}
| 1,335 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
IsCellEditMode.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/waits/IsCellEditMode.java | package net.heartsome.cat.ts.test.ui.waits;
import net.heartsome.cat.ts.test.ui.editors.XlfEditor;
import net.heartsome.cat.ts.test.ui.utils.XliffUtil;
import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
/**
* 判断编辑器单元格是否为编辑状态。
*/
public class IsCellEditMode extends DefaultCondition {
private XlfEditor editor;
private String styledText;
private String styledTextNotNull;
private String expectedTextNotNull;
// 用 InnerTagUtil 将 NatTable 中直接取到的纯文本转为简单标记形式显示的文本
private String taggedText;
/**
* @param editor
* XlfEditor 对象，自动从其中得到编辑模式中的 StyledText 内容
* @param expectedTextNotNull
* 预期的文本，用于对比判断从 XlfEditor 中得到的 StyledText 是否与该预期内容一致
*/
public IsCellEditMode(XlfEditor editor, String expectedTextNotNull) {
this.editor = editor;
this.expectedTextNotNull = expectedTextNotNull;
taggedText = XliffUtil.tagged(expectedTextNotNull);
}
/** (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#test()
*/
public boolean test() throws Exception {
styledText = editor.getStyledText().getText();
// 该样式文本框没有值时当作空字符串处理
styledTextNotNull = (styledText == null ? "" : styledText);
// 若编辑器为显示标记源文本状态，则直接对比从 NatTable 取到的纯文本；
// 若为显示简单标记状态，则对比按 InnerTagUtil 处理后的样式文本。
// 从界面上无法直接取到标记的显示状态，所以只要这两个对比结果中任一个成立即可。
return expectedTextNotNull.equals(styledTextNotNull) || taggedText.equals(styledTextNotNull);
}
/** (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#getFailureMessage()
*/
public String getFailureMessage() {
return "以下预期内容的单元格未进入编辑模式：" + expectedTextNotNull;
}
}
| 2,006 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
IsEditorLayoutHorizontal.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/waits/IsEditorLayoutHorizontal.java | package net.heartsome.cat.ts.test.ui.waits;
import net.heartsome.cat.ts.test.ui.editors.XlfEditor;
import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
/**
* 判断编辑器是否为水平布局。
*/
public class IsEditorLayoutHorizontal extends DefaultCondition {
private XlfEditor xlfEditor;
/**
* 判断编辑器是否为水平布局
* @param xlfEditor
*/
public IsEditorLayoutHorizontal(XlfEditor xlfEditor) {
this.xlfEditor = xlfEditor;
}
/** (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#test()
*/
public boolean test() throws Exception {
return xlfEditor.isHorizontalLayout();
}
/** (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#getFailureMessage()
*/
public String getFailureMessage() {
return "该编辑器不是水平布局：" + xlfEditor.getTitle();
}
}
| 858 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
IsEditorLayoutVertical.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/waits/IsEditorLayoutVertical.java | package net.heartsome.cat.ts.test.ui.waits;
import net.heartsome.cat.ts.test.ui.editors.XlfEditor;
import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
/**
* 判断编辑器是否为垂直布局。
*/
public class IsEditorLayoutVertical extends DefaultCondition {
private XlfEditor xlfEditor;
/**
* 判断编辑器是否为垂直布局
* @param xlfEditor
*/
public IsEditorLayoutVertical(XlfEditor xlfEditor) {
this.xlfEditor = xlfEditor;
}
/** (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#test()
*/
public boolean test() throws Exception {
return !xlfEditor.isHorizontalLayout();
}
/** (non-Javadoc)
* @see org.eclipse.swtbot.swt.finder.waits.ICondition#getFailureMessage()
*/
public String getFailureMessage() {
return "该编辑器不是垂直布局：" + xlfEditor.getTitle();
}
}
| 855 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
XlfEditor.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/editors/XlfEditor.java | package net.heartsome.cat.ts.test.ui.editors;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import net.heartsome.cat.common.ui.utils.InnerTagUtil;
import net.heartsome.cat.ts.core.file.XLFHandler;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.utils.XliffUtil;
import net.heartsome.cat.ts.test.ui.waits.IsCellEditMode;
import net.heartsome.cat.ts.test.ui.waits.IsEditorLayoutHorizontal;
import net.heartsome.cat.ts.test.ui.waits.IsEditorLayoutVertical;
import net.heartsome.cat.ts.test.ui.waits.IsSegmentSelected;
import net.heartsome.cat.ts.ui.editors.IXliffEditor;
import net.heartsome.test.swtbot.finders.HsSWTWorkbenchBot;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.waits.IsCellSelected;
import net.heartsome.test.swtbot.waits.IsComboEquals;
import net.heartsome.test.swtbot.widgets.HsSWTBotStyledText;
import net.heartsome.test.swtbot.widgets.SWTBotNatTable;
import net.heartsome.test.utilities.nattable.LayerUtil;
import org.eclipse.core.runtime.Assert;
import org.eclipse.swtbot.eclipse.finder.finders.WorkbenchContentsFinder;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotEditor;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.SWTBotAssert;
import org.eclipse.swtbot.swt.finder.keyboard.Keystrokes;
import org.eclipse.swtbot.swt.finder.utils.Position;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotCombo;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarButton;
import org.eclipse.ui.IEditorPart;
/**
* XLIFF 编辑器
* @author felix_lu
* @version
* @since JDK1.6
*/
public class XlfEditor extends SWTBotEditor {
private static HsSWTWorkbenchBot bot = HSBot.bot();
private SWTBot editorBot = this.bot();
private TS ts = TS.getInstance();
/** 记录最后输入的跳转行数 */
private String lineNumLastValue = TsUIConstants.getString("txtLineNumber");
/** StyleText 中显示标记用的分隔符，不可见字符 */
public static final char INVISIBLE_CHAR = InnerTagUtil.INVISIBLE_CHAR;
/** 编辑器的内容区 NatTable */
public SWTBotNatTable nattable;
/**
* 按指定的编辑器对象创建
* @param editor
*/
public XlfEditor(SWTBotEditor editor) {
super(editor.getReference(), bot);
getNatTable();
}
/**
* ************ XLIFF 编辑器的一些基本操作 ************ 包括语言对过滤器、文本段过滤器
*/
/**
* 得到指定文件名所在的编辑器
* @param fileName
* 指定的文件名
* @return XlfEditor 得到的编辑器
*/
// public static XlfEditor getInstance(String fileName) {
// return new XlfEditor(bot.editorByTitle(fileName));
// }
/**
* 不指定文件名时，取得当前激活的编辑器
* @return XlfEditor 当前激活的编辑器
*/
// public static XlfEditor getInstance() {
// return new XlfEditor(bot.activeEditor());
// }
/**
* @return SWTBotCombo 编辑器中的语言对下拉列表
*/
public SWTBotCombo getLangCombo() {
Pattern langCode = Pattern.compile("[a-z]{2}(-[A-Z]{2})? -> [a-z]{2}(-[A-Z]{2})?");
int index = 0;
while (true) {
Matcher m = langCode.matcher(editorBot.comboBox(index).getText());
if (m.find()) {
return editorBot.comboBox(index);
}
index++;
}
}
/**
* 选择指定的语言对
* @param srcLang
* 源语言代码
* @param tgtLang
* 目标语言代码
*/
public void selectLangPair(String srcLang, String tgtLang) {
String langPair = srcLang + " -> " + tgtLang;
SWTBotCombo langCombo = getLangCombo();
langCombo.setSelection(langPair);
bot.waitUntil(new IsComboEquals(langCombo, langPair));
SWTBotAssert.assertText(langPair, langCombo);
}
/**
* 取得当前源语言代码
* @return String 当前源语言代码
*/
public String getSourceLangCode() {
return getLangCombo().getText().split(" -> ")[0];
}
/**
* 取得当前目标语言代码
* @return String 当前目标语言代码
*/
public String getTargetLangCode() {
return getLangCombo().getText().split(" -> ")[1];
}
/**
* 得到文本段过滤器下拉列表
* @return SWTBotCombo 文本段过滤器下拉列表
*/
public SWTBotCombo getSegFilterCombo() {
String defaultFilter = TsUIConstants.getString("cmbSegFilterAllSegments");
int index = 0;
while (true) {
SWTBotCombo segFilterCombo = editorBot.comboBox(index);
if (segFilterCombo.getText().equals(defaultFilter)) {
return segFilterCombo;
}
index++;
}
}
/**
* 选择指定的文本段过滤器
* @param filterName
* 过滤器名称
*/
public void selectSegFilter(final String filterName) {
SWTBotCombo segFilterCombo = getSegFilterCombo();
segFilterCombo.setSelection(filterName);
bot.waitUntil(new IsComboEquals(segFilterCombo, filterName));
SWTBotAssert.assertText(filterName, segFilterCombo);
}
/**
* 添加自定义过滤器按钮
* @return SWTBotButton
*/
public SWTBotButton btnAddCustomFilter() {
return editorBot.button(TsUIConstants.getString("btnAddCustomFilter"));
}
/**************
* XLIFF 编辑器中的 NatTable 相关操作 ************ 包括切换布局、文本段跳转、源/目标文本的选择等
*/
/**
* 取得编辑器中的 NatTable
* @return SWTBotNatTable 编辑器中的 NatTable
*/
public SWTBotNatTable getNatTable() {
nattable = bot.natTable();
return nattable;
}
/**
* 点击指定的右键菜单
* @param texts 右键菜单文本，每一级菜单为一个参数;
*/
public void clickContextMenu(String... texts) {
getNatTable().clickContextMenu(texts);
}
/**
* @return List<String> 当前文件中所有文本段的 RowID，合并、分割文本段后应重新获取 （每个 RowID 由 XLIFF 文件路径、源文件路径、trans-unit ID 组成）
*/
public List<String> getAllRowIds() {
WorkbenchContentsFinder finder = new WorkbenchContentsFinder();
IEditorPart activateEditor = finder.activeWorkbenchWindow().getActivePage().getActiveEditor();
IXliffEditor xliffEditor = (IXliffEditor) activateEditor;
XLFHandler handler = xliffEditor.getXLFHandler();
return handler.getAllRowIds();
}
/**
* @return List<String> 当前所有可见文本段的 RowID，合并、分割文本段后应重新获取
*/
public ArrayList<String> getRowIds() {
WorkbenchContentsFinder finder = new WorkbenchContentsFinder();
IEditorPart activateEditor = finder.activeWorkbenchWindow().getActivePage().getActiveEditor();
IXliffEditor xliffEditor = (IXliffEditor) activateEditor;
XLFHandler handler = xliffEditor.getXLFHandler();
return handler.getRowIds();
}
/**
* @param segNum
* 文本段序号，合并、分割文本段和排序后应重新获取
* @return String 文本段 RowID
*/
public String rowIdOfSegNum(int segNum) {
Assert.isTrue(segNum > 0, "Invalid segment number: " + segNum);
return getRowIds().get(segNum - 1);
}
/**
* @return String 当前选中的文本段 RowID
*/
public String rowIdOfSelectedSeg() {
getNatTable();
int colPosOfLineNumHeader = nattable.positionOfColumn(lblNatTableHeaderLineNum());
int rowPosOfLineSelected = nattable.positionOfSelectedRow(colPosOfLineNumHeader);
String segNum = nattable.getTextByPosition(rowPosOfLineSelected, colPosOfLineNumHeader);
return rowIdOfSegNum(Integer.valueOf(segNum) - 1);
}
/**
* @param segNum
* 文本段序号，合并、分割文本段和排序后应重新获取
* @return String 文本段的 trans-unit id
*/
public String tuidOfSegNum(int segNum) {
String rowID = rowIdOfSegNum(segNum);
XliffUtil xu = new XliffUtil(rowID);
return xu.getAttributeOfTU("id");
}
/**
* @return String 当前选中的文本段的 trans-unit id
*/
public String tuidOfSelectedSeg() {
String rowID = rowIdOfSelectedSeg();
XliffUtil xu = new XliffUtil(rowID);
return xu.getAttributeOfTU("id");
}
/**
* 判断指定文件的编辑器是否为水平布局
* @return boolean true 表示水平布局、false 表示垂直布局
*/
public boolean isHorizontalLayout() {
Pattern columnHeader = Pattern.compile("[a-z]{2}(-[A-Z]{2})? -> [a-z]{2}(-[A-Z]{2})?");
int columnCount = getNatTable().columnCount();
for (int i = 0; i < columnCount; i++) {
Matcher m = columnHeader.matcher(getNatTable().getTextByPosition(0, i));
if (m.find()) {
return false;
}
}
return true;
}
/**
* 修改编辑器布局 将编辑器布局由水平改为垂直，或反之
*/
public void changeEditorLayout() {
XlfEditor xe = new XlfEditor(bot.activeEditor());
SWTBotToolbarButton changeEditorLayout = TS.getInstance().tlbBtnWTltChangeEditorLayout();
if (xe.isHorizontalLayout()) {
changeEditorLayout.click();
// 修改布局会导致 NatTable 重绘，重新赋值以更新其他地方的引用
getNatTable();
bot.waitUntil(new IsEditorLayoutVertical(xe));
} else {
changeEditorLayout.click();
getNatTable();
bot.waitUntil(new IsEditorLayoutHorizontal(xe));
}
}
/**
* 跳到指定文本段
* @param segNum
* 文本段行号
*/
public void gotoSeg(int segNum) {
getNatTable();
nattable.click(1, 1);
int targetRowIndex;
if (isHorizontalLayout()) {
targetRowIndex = segNum - 1;
} else {
targetRowIndex = (segNum - 1) * 2;
}
int selectedRowIndex = nattable.indexOfSelectedRow(positionOfTargetTextColumn());
// 先判断指定文本段是否已经被选中，若未被选中才继续
if (segNum != 1 && targetRowIndex != selectedRowIndex) {
SWTBotText text = editorBot.text(lineNumLastValue);
text.setText(String.valueOf(segNum));
text.pressShortcut(Keystrokes.LF);
lineNumLastValue = String.valueOf(segNum);
// 确认选中了指定文本段
bot.waitUntil(new IsSegmentSelected(this, targetRowIndex));
}
}
/**
* @return int 当前 NatTable 中的总文本段数量
*/
public int segCount() {
getNatTable();
LayerUtil.setBodyLayerPosition(0, 1); // 设置 NatTable 的 Body 位置
// 每次重绘 NatTable 后需要重新获取该 DataLayer
int lineCount = nattable.rowCountData(); // 计算数据行数
if (isHorizontalLayout()) {
return lineCount;
} else {
return lineCount / 2;
}
}
/**
* @return int 当前编辑器中源语言所在列的 Position
*/
public int positionOfSourceTextColumn() {
getNatTable();
if (isHorizontalLayout()) {
return nattable.positionOfColumn(getSourceLangCode());
} else {
return nattable.positionOfColumn(getLangCombo().getText());
}
}
/**
* @return int 当前编辑器中源语言所在列的 Index
*/
public int indexOfSourceTextColumn() {
getNatTable();
if (isHorizontalLayout()) {
return nattable.indexOfColumn(getSourceLangCode());
} else {
return nattable.indexOfColumn(getLangCombo().getText());
}
}
/**
* @return int 当前编辑器中目标语言所在列的 Position
*/
public int positionOfTargetTextColumn() {
getNatTable();
if (isHorizontalLayout()) {
return nattable.positionOfColumn(getTargetLangCode());
} else {
return nattable.positionOfColumn(getLangCombo().getText());
}
}
/**
* @return int 当前编辑器中目标语言所在列的 Index
*/
public int indexOfTargetTextColumn() {
getNatTable();
if (isHorizontalLayout()) {
return nattable.indexOfColumn(getTargetLangCode());
} else {
return nattable.indexOfColumn(getLangCombo().getText());
}
}
/**
* @param text
* 文本内容，其中的内部标记为源代码形式（必须对其中的双引号进行转义）
* @return int 从第一个文本段起，源文本内容等于指定内容的文本段序号（精确匹配）
*/
public int segNumOfSource(String text) {
return segNumOfSource(text, 1);
}
/**
* @param text
* 文本内容，其中的内部标记为源代码形式（必须对其中的双引号进行转义）
* @param fromSegNum
* 查找的起始文本段序号
* @return int 从指定序号的文本段起，源文本内容等于指定内容的文本段序号（精确匹配）
*/
public int segNumOfSource(String text, int fromSegNum) {
if (text == null) {
return -1;
}
getNatTable();
nattable.click(1, 1);
int columnPosition = positionOfSourceTextColumn();
int rowPosition;
String srcText;
selectSourceCell(fromSegNum);
for (int i = fromSegNum; i <= segCount(); i++) {
rowPosition = nattable.positionOfSelectedRow();
srcText = nattable.getTextByPosition(rowPosition, columnPosition);
if (text.equals(srcText) || text.equals(XliffUtil.tagged(srcText))) {
// 考虑标记的两种显示状态
int columnHeaderPosition = nattable.positionOfColumn(TsUIConstants
.getString("lblNatTableHeaderLineNum"));
return Integer.valueOf(nattable.getTextByPosition(rowPosition, columnHeaderPosition));
}
nattable.pressShortcut(Keystrokes.DOWN); // 输入向下方向键
}
return -1;
}
/**
* @param text
* 文本内容，其中的内部标记为源代码形式（必须对其中的双引号进行转义）
* @return int 从第一个文本段起，源文本内容包含指定内容的文本段序号（模糊匹配）
*/
public int segNumContainsSource(String text) {
return segNumContainsSource(text, 1);
}
/**
* @param text
* 文本内容，其中的内部标记为源代码形式（必须对其中的双引号进行转义）
* @param fromSegNum
* 查找的起始文本段序号
* @return int 从指定序号的文本段起，源文本内容包含指定内容的文本段序号（模糊匹配）
*/
public int segNumContainsSource(String text, int fromSegNum) {
if (text == null) {
return -1;
}
getNatTable();
int columnPosition = positionOfSourceTextColumn();
int rowPosition;
String srcText;
selectSourceCell(fromSegNum);
for (int i = fromSegNum; i <= segCount(); i++) {
rowPosition = nattable.positionOfSelectedRow();
srcText = nattable.getTextByPosition(rowPosition, columnPosition);
if (srcText != null && (srcText.contains(text) || XliffUtil.tagged(srcText).contains(text))) {
// 考虑标记的两种显示状态
int columnHeaderPosition = nattable.positionOfColumn(TsUIConstants
.getString("lblNatTableHeaderLineNum"));
return Integer.valueOf(nattable.getTextByPosition(rowPosition, columnHeaderPosition));
}
nattable.pressShortcut(Keystrokes.DOWN); // 输入向下方向键
}
return -1;
}
/**
* 选择指定行的源文本
* @param segNum
* 欲选择的文本段行号
*/
public void selectSourceCell(int segNum) {
getNatTable();
gotoSeg(segNum); // 先跳转到该文本段，确保其被显示
int sourceColumnPosition = positionOfSourceTextColumn();
int selectedRowPosition = nattable.positionOfSelectedRow(sourceColumnPosition);
// 先点击一下行首，保证目标文本框完全显示在界面上
nattable.click(selectedRowPosition, 0);
// 重新取当前选中行的位置，因为刚才的点击可能引起了改变
selectedRowPosition = nattable.positionOfSelectedRow(sourceColumnPosition);
// 这两个 Index 用来判断指定的单元格在操作完成后是否确实被选中
int targetRowIndex = nattable.getRowIndexByPosition(selectedRowPosition);
int targetColumnIndex = indexOfSourceTextColumn();
// 点击之后，Position 可能会发生改变，所以必须在点击之前赋以上两个值
nattable.click(selectedRowPosition, sourceColumnPosition);
bot.waitUntil(new IsCellSelected(nattable, targetRowIndex, targetColumnIndex));
}
/**
* 选择指定行的目标文本
* @param segNum
* 欲选择的文本段行号
*/
public void selectTargetCell(int segNum) {
getNatTable();
gotoSeg(segNum);
int targetColumnPosition = positionOfTargetTextColumn();
int targetRowPosition = nattable.positionOfSelectedRow(targetColumnPosition);
// 先点击一下行首，保证目标文本框完全显示在界面上
nattable.click(targetRowPosition, 0);
// 重新取当前选中行的位置，因为刚才的点击可能引起了改变
targetRowPosition = nattable.positionOfSelectedRow(targetColumnPosition);
if (!isHorizontalLayout()) {
targetRowPosition += 1;
}
// 这两个 Index 用来判断指定的单元格在操作完成后是否确实被选中
int targetColumnIndex = indexOfTargetTextColumn();
int targetRowIndex = nattable.getRowIndexByPosition(targetRowPosition);
// 点击之后，Position 可能会发生改变，所以必须在点击之前赋以上两个值
nattable.click(targetRowPosition, targetColumnPosition);
bot.waitUntil(new IsCellSelected(nattable, targetRowIndex, targetColumnIndex));
}
/**
* 进入编辑源文本状态
* @param segNum
* 欲编辑的文本段行号
*/
public void enterEditModeSource(int segNum) {
getNatTable();
gotoSeg(segNum); // 先跳转到该文本段，确保其被显示
int sourceColumnPosition = positionOfSourceTextColumn();
int selectedRowPosition = nattable.positionOfSelectedRow(sourceColumnPosition);
// 先点击一下行首，保证目标文本框完全显示在界面上
nattable.click(selectedRowPosition, 0);
// 重新取当前选中行的位置，因为刚才的点击可能引起了改变
selectedRowPosition = nattable.positionOfSelectedRow(sourceColumnPosition);
String textOfCell = nattable.getTextByPosition(selectedRowPosition, positionOfSourceTextColumn());
// 该节点没有值时当作空字符串处理
String textOfCellNotNull = (textOfCell == null ? "" : textOfCell);
// 点击之后，Position 可能会改变，所以必须在点击之前赋值
nattable.doubleClick(selectedRowPosition, sourceColumnPosition);
bot.waitUntil(new IsCellEditMode(this, textOfCellNotNull));
}
/**
* 进入编辑目标文本状态
* @param segNum
* 欲编辑的文本段行号
*/
public void enterEditModeTarget(int segNum) {
getNatTable();
gotoSeg(segNum);
int targetColumnPosition = positionOfTargetTextColumn();
int targetRowPosition = nattable.positionOfSelectedRow(targetColumnPosition);
// 先点击一下行首，保证目标文本框完全显示在界面上
nattable.click(targetRowPosition, 0);
// 重新取当前选中行的位置，因为刚才的点击可能引起了改变
targetRowPosition = nattable.positionOfSelectedRow(targetColumnPosition);
if (!isHorizontalLayout()) {
targetRowPosition += 1;
}
String textOfCell = nattable.getTextByPosition(targetRowPosition, positionOfTargetTextColumn());
// 该节点没有值时当作空字符串处理
final String textOfCellNotNull = (textOfCell == null ? "" : textOfCell);
// 点击之后，Position 可能会改变，所以必须在点击之前赋值
nattable.doubleClick(targetRowPosition, targetColumnPosition);
bot.waitUntil(new IsCellEditMode(this, textOfCellNotNull));
}
/**
* @return boolean 判断 NatTable 是否按源或目标列排序
*/
public boolean isSorted() {
getNatTable();
return nattable.sortStatus(positionOfSourceTextColumn()) != 0
&& nattable.sortStatus(positionOfTargetTextColumn()) != 0;
}
/**************
* XLIFF 编辑器中的 StyledText 相关操作 ************ 包括将光标放置于源/目标文本中的指定位置、输入或删除源/目标文本 的指定字符/字符串等
*/
/**
* 返回 NatTable 中的 StyledText 以区分其他地方的相同控件（如记忆库翻译匹配面板、快速翻译面板中）
* @return SWTBotStyledText 当前编辑器的 NatTable 中的 StyledText
*/
public HsSWTBotStyledText getStyledText() {
getNatTable();
return bot.styledText(nattable);
}
/**
* 将光标定位到文本框首 在样式文本框中移动光标到开始位置
*/
public void navigateToBegining() {
HsSWTBotStyledText styledText = getStyledText();
styledText.navigateTo(0, 0);
}
/**
* 将光标定位到文本框末 在样式文本框中移动光标到结束位置
*/
public void navigateToEnd() {
HsSWTBotStyledText styledText = getStyledText();
int length = styledText.getText().length();
styledText.navigateTo(styledText.getPositionByIndex(length));
}
/**
* 将光标定位到指定索引位置
* @param index
* 目标位置的索引
*/
public void navigateToIndex(int index) {
HsSWTBotStyledText styledText = getStyledText();
styledText.navigateTo(styledText.getPositionByIndex(index));
}
/**
* 将光标定位到指定字符串之前
* @param beforeText
* 指定的字符串，光标将置于其第一个字符之前
*/
public void navigateBefore(String beforeText) {
HsSWTBotStyledText styledText = getStyledText();
Position targetPos = styledText.positionOf(beforeText);
Assert.isTrue(!targetPos.equals(new Position(-1, -1)), "Text \"" + beforeText + "\" not found.");
styledText.navigateTo(targetPos);
}
/**
* 将光标定位到指定字符串之后
* @param afterText
* 指定的字符串，光标将置于其最后一个字符之后
*/
public void navigateAfter(String afterText) {
HsSWTBotStyledText styledText = getStyledText();
Position targetPos = styledText.positionOfFollowing(afterText);
Assert.isTrue(!targetPos.equals(new Position(-1, -1)), "Text \"" + afterText + "\" not found.");
styledText.navigateTo(targetPos);
}
/**
* 将光标定位到指定的两个字符串之间 指定的两个字符串必须相邻
* @param afterText
* 指定的字符串，光标将置于其最后一个字符之后
* @param beforeText
* 指定的字符串，光标将置于其第一个字符之前
*/
public void navigateBetween(String afterText, String beforeText) {
HsSWTBotStyledText styledText = getStyledText();
Position targetPosA = styledText.positionOfFollowing(afterText);
Assert.isTrue(!targetPosA.equals(new Position(-1, -1)), "Text \"" + afterText + "\" not found.");
Position targetPosB = styledText.positionOf(beforeText);
Assert.isTrue(!targetPosB.equals(new Position(-1, -1)), "Text \"" + beforeText + "\" not found.");
Assert.isTrue(targetPosB.equals(targetPosA), "Text \"" + afterText + beforeText + "\" not found.");
styledText.navigateTo(targetPosA);
}
/**
* 在文本框开始位置输入内容
* @param text
* 要输入的内容
*/
public void typeTextBegining(String text) {
navigateToBegining();
HsSWTBotStyledText styledText = getStyledText();
styledText.typeText(text);
}
/**
* 在文本框结束位置输入内容
* @param text
* 要输入的内容
*/
public void typeTextEnd(String text) {
navigateToEnd();
HsSWTBotStyledText styledText = getStyledText();
styledText.typeText(text);
}
/**
* 在指定字符串之前输入内容
* @param beforeText
* 指定的字符串，输入的内容将在其第一个字符之前
* @param text
* 要输入的内容
*/
public void typeTextBefore(String beforeText, String text) {
HsSWTBotStyledText styledText = getStyledText();
Position targetPos = styledText.positionOf(beforeText);
Assert.isTrue(!targetPos.equals(new Position(-1, -1)), "Text \"" + beforeText + "\" not found.");
styledText.typeText(targetPos.line, targetPos.column, text);
}
/**
* 在指定字符串之后输入内容
* @param afterText
* 指定的字符串，输入的内容将在其最后一个字符之后
* @param text
* 要输入的内容
*/
public void typeTextAfter(String afterText, String text) {
HsSWTBotStyledText styledText = getStyledText();
Position targetPos = styledText.positionOfFollowing(afterText);
Assert.isTrue(!targetPos.equals(new Position(-1, -1)), "Text \"" + afterText + "\" not found.");
styledText.typeText(targetPos.line, targetPos.column, text);
}
/**
* 在指定的两个字符串之间输入内容
* @param afterText
* 指定的字符串，输入的内容将在其最后一个字符之后
* @param beforeText
* 指定的字符串，输入的内容将在其第一个字符之前
* @param text
* 要输入的内容
*/
public void typeTextBetween(String afterText, String beforeText, String text) {
HsSWTBotStyledText styledText = getStyledText();
Position targetPosA = styledText.positionOfFollowing(afterText);
Assert.isTrue(!targetPosA.equals(new Position(-1, -1)), "Text \"" + afterText + "\" not found.");
Position targetPosB = styledText.positionOf(beforeText);
Assert.isTrue(!targetPosB.equals(new Position(-1, -1)), "Text \"" + beforeText + "\" not found.");
Assert.isTrue(targetPosB.equals(targetPosA), "Text \"" + afterText + beforeText + "\" not found.");
styledText.typeText(targetPosA.line, targetPosA.column, text);
}
/**
* 删除第一个匹配的内容
* @param text
* 要删除的内容
*/
public void deleteFirstText(String text) {
HsSWTBotStyledText styledText = getStyledText();
styledText.setText(styledText.getText().replaceFirst(text, ""));
}
/**
* 删除所有匹配的内容
* @param text
* 要删除的内容
*/
public void deleteAllText(String text) {
HsSWTBotStyledText styledText = getStyledText();
styledText.setText(styledText.getText().replaceAll(text, ""));
}
/************** 编辑器相关的状态栏信息读取 ************ */
/**
* @return String 状态栏中的当前编辑器所打开的文件路径
*/
public String stbCurrentFile() {
return ts.getStatusBarValueByKey(ts.stbiCurrentFile());
}
/**
* @return int 状态栏中的当前文本段序号
*/
public int stbSegmentNumber() {
return Integer.valueOf(ts.getStatusBarValueByKey(ts.stbiSegmentNumber()));
}
/**
* @return int 状态栏中的可见文本段数量
*/
public int stbVisibleSegmentCount() {
return Integer.valueOf(ts.getStatusBarValueByKey(ts.stbiVisibleSegmentCount()));
}
/**
* @return int 状态栏中的文本段总数
*/
public int stbSegmentTotalCount() {
return Integer.valueOf(ts.getStatusBarValueByKey(ts.stbiSegmentTotalCount()));
}
/**
* @return String 状态栏中的当前用户名
*/
public String stbUsername() {
return ts.getStatusBarValueByKey(ts.stbiUsername());
}
/************** 界面文本 ************ */
/**
* @return 行号;
*/
public String lblNatTableHeaderLineNum() {
return TsUIConstants.getString("lblNatTableHeaderLineNum");
}
/**
* @return 状态;
*/
public String lblNatTableHeaderStatus() {
return TsUIConstants.getString("lblNatTableHeaderStatus");
}
/**
* @return 设置文本段批准状态;
*/
public String ctxMenuApproveStatus() {
return TsUIConstants.getString("ctxMenuApproveStatus");
}
/**
* @return 批准当前文本段;
*/
public String ctxMenuapproveStatusApproveCurrentSeg() {
return TsUIConstants.getString("approveStatusApproveCurrentSeg");
}
/**
* @return 取消批准当前文本段;
*/
public String ctxMenuapproveStatusUnapproveCurrentSeg() {
return TsUIConstants.getString("approveStatusUnapproveCurrentSeg");
}
/**
* @return 设置文本段锁定状态;
*/
public String ctxMenuLockStatus() {
return TsUIConstants.getString("ctxMenuLockStatus");
}
/**
* @return 锁定当前文本段;
*/
public String ctxMenulockStatusLockCurrentSeg() {
return TsUIConstants.getString("lockStatusLockCurrentSeg");
}
/**
* @return 取消锁定当前文本段;
*/
public String ctxMenulockStatusUnlockCurrentSeg() {
return TsUIConstants.getString("lockStatusUnlockCurrentSeg");
}
/**
* @return 锁定重复文本段;
*/
public String ctxMenulockStatusLockRepetitionSegs() {
return TsUIConstants.getString("lockStatusLockRepetitionSegs");
}
/**
* @return 取消锁定重复文本段;
*/
public String ctxMenulockStatusUnlockRepetitionSegs() {
return TsUIConstants.getString("lockStatusUnlockRepetitionSegs");
}
/**
* @return 设置目标文本段状态;
*/
public String ctxMenuTargetState() {
return TsUIConstants.getString("ctxMenuTargetState");
}
// public String ctxMenuTargetStatenew() {
// return TsUIConstants.getString("TargetStateNew");
// }
//
// public String ctxMenuTargetStatefinal() {
// return TsUIConstants.getString("TargetStatefinal");
// }
//
// public String ctxMenuTargetStatetranslated() {
// return TsUIConstants.getString("TargetStatetranslated");
// }
//
// public String ctxMenuTargetStatesigned_off() {
// return TsUIConstants.getString("TargetStatesigned-off");
// }
//
// public String ctxMenuTargetStateneeds_adaptation() {
// return TsUIConstants.getString("TargetStateneeds-adaptation");
// }
//
// public String ctxMenuTargetStateneeds_reivew_adaptation() {
// return TsUIConstants.getString("TargetStateneeds-reivew-adaptation");
// }
//
// public String ctxMenuTargetStateneeds_l10n() {
// return TsUIConstants.getString("TargetStateneeds-l10n");
// }
//
// public String ctxMenuTargetStateneeds_review_l10n() {
// return TsUIConstants.getString("TargetStateneeds-review-l10n");
// }
//
// public String ctxMenuTargetStateneeds_translation() {
// return TsUIConstants.getString("TargetStateneeds-translation");
// }
//
// public String ctxMenuTargetStateneeds_review_translation() {
// return TsUIConstants.getString("TargetStateneeds-review-translation");
// }
/************** 一些常用的任务 ************ */
/**
* @param expectedText 字符串数组：分割后的文本段内容
* @return XliffUtil 数组：分割后的新 XliffUtil 对象;
*/
public XliffUtil[] getSplitXliffUtil(String[] expectedText) {
XliffUtil[] xu = new XliffUtil[2];
int segNum1 = segNumOfSource(expectedText[0]);
String rowID1 = rowIdOfSegNum(segNum1);
xu[0] = new XliffUtil(rowID1);
int segNum2 = segNumOfSource(expectedText[1]);
String rowID2 = rowIdOfSegNum(segNum2);
xu[1] = new XliffUtil(rowID2);
return xu;
}
}
| 30,190 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
TsUIConstants.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/constants/TsUIConstants.java | package net.heartsome.cat.ts.test.ui.constants;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.List;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import net.heartsome.cat.common.locale.LocaleService;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotCombo;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotList;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotRadio;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
/**
* @author felix_lu
* @version
* @since JDK1.6
*/
public final class TsUIConstants {
private static final String BUNDLE_NAME = "net.heartsome.cat.ts.test.ui.constants.TsUIConstants"; //$NON-NLS-1$
private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle(BUNDLE_NAME);
/**
* 私有构造函数
*/
private TsUIConstants() {
// private constructor
}
/**
* 功能入口
* @author felix_lu
* @version
* @since JDK1.6
*/
public enum Entry {
MENU, TOOLBAR, SHORTCUT, CONTEXT_MENU, CONTEXT_MENU_ALT, DOUBLE_CLICK,
}
/**
* 预期结果
* @author felix_lu
* @version
* @since JDK1.6
*/
public enum ExpectedResult {
SUCCESS, DUPLICATED_NAME, INVALID_NAME, NO_FILE, NO_DB, FILE_ERROR, WRONG_TYPE, INVALID_FILE, INVALID_PATH, NO_SERVER, NO_PORT, NO_INSTANCE, NO_USERNAME, NO_PATH, CONNECTION_ERROR, LONG_NAME,
}
/**
* 更新策略
* @author felix_lu
* @version
* @since JDK1.6
*/
public enum UpdateMode {
ALWAYS_ADD, OVERWRITE, IGNORE, MERGE, KEEP_CURRENT, OVERWRITE_IF_HIGHER
}
/**
* 数据库类型
* @author felix_lu
* @version
* @since JDK1.6
*/
public enum DB {
INTERNAL, MYSQL, ORACLE, POSTGRESQL, MSSQL,
}
/**
* 导入类型
* @author felix_lu
* @version
* @since JDK1.6
*/
public enum ImportType {
TMX, TBX,
}
/**
* 资源类型
* @author felix_lu
* @version
* @since JDK1.6
*/
public enum ResourceType {
PROJECT, FOLDER, FILE,
}
/**
* 标记样式
* @author felix_lu
*
*/
public enum TagStyle {
INDEX, SIMPLE, FULL,
}
/**
* 根据 key，获得相应的 value 值
* @param key
* @return ;
*/
public static String getString(String key) {
try {
return RESOURCE_BUNDLE.getString(key);
} catch (MissingResourceException e) {
return '!' + key + '!';
}
}
/**
* @param langCode
* 语言代码
* @return 字符串：语言代码 ＋ 空格 ＋ 语言名称;
*/
public static String getLang(String langCode) {
String lang = LocaleService.getLanguage(langCode);
assertTrue("未找到该语言代码对应的语言：" + langCode, !"".equals(lang));
return lang;
}
/**
* @param langCodes
* 语言代码数组
* @return 语言数组，每个值为字符串：语言代码 ＋ 空格 ＋ 语言名称;
*/
public static String[] getLangs(String... langCodes) {
int len = langCodes.length;
String[] langs = new String[len];
for (int i = 0; i < len; i++) {
langs[i] = getLang(langCodes[i]);
}
return langs;
}
/**
* @param langCodes
* @return 语言 List;
*/
public static List<String> getLangs(List<String> langCodes) {
List<String> lang = new ArrayList<String>();
for (String langCode : langCodes) {
lang.add(getLang(langCode));
}
return lang;
}
/**
* @param bot
* 对话框的 SWTBot 对象
* @param buttonKey
* 按钮上的文字标签
* @param index
* 索引号
* @return
*/
public static SWTBotButton button(SWTBot bot, String buttonKey, int index) {
return bot.button(getString(buttonKey), index);
}
/**
* @param bot
* 对话框的 SWTBot 对象
* @param buttonKey
* 按钮上的文字标签
* @return
*/
public static SWTBotButton button(SWTBot bot, String buttonKey) {
return bot.button(getString(buttonKey));
}
/**
* @param bot
* 对话框的 SWTBot 对象
* @param labelKey
* 列表的文字标签
* @return
*/
public static SWTBotList listWithLabel(SWTBot bot, String labelKey) {
return bot.listWithLabel(getString(labelKey));
}
/**
* @param bot
* @param valueKey
* @return ;
*/
public static SWTBotCombo comboBox(SWTBot bot, String valueKey) {
return bot.comboBox(getString(valueKey));
}
/**
* @param bot
* @param labelKey
* @return ;
*/
public static SWTBotCombo comboBoxWithLabel(SWTBot bot, String labelKey) {
return bot.comboBoxWithLabel(getString(labelKey));
}
/**
* @param bot
* @param textKey
* @return ;
*/
public static SWTBotText text(SWTBot bot, String textKey) {
return bot.text(getString(textKey));
}
/**
* @param bot
* @param labelKey
* @return ;
*/
public static SWTBotText textWithLabel(SWTBot bot, String labelKey) {
return bot.textWithLabel(getString(labelKey));
}
/**
* @param bot
* @param radioKey
* @return ;
*/
public static SWTBotRadio radio(SWTBot bot, String radioKey) {
return bot.radio(getString(radioKey));
}
}
| 5,109 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
NewFolderDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/NewFolderDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 新建文件夹向导对话框
* @author felix_lu
* @version
* @since JDK1.6
*/
public class NewFolderDialog extends NewWizardDialog {
private SWTBot dialogBot = this.bot();
/**
* 按标题查找对话框
*/
public NewFolderDialog() {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitleNewFolder")).widget);
}
/**
* @return SWTBotButton 高级 非展开状态
*/
public SWTBotButton btnAdvancedCollapsed() {
return dialogBot.button(TsUIConstants.getString("btnAdvancedCollapsed"));
}
/**
* @return SWTBotButton 高级 展开状态
*/
public SWTBotButton btnAdvancedExpanded() {
return dialogBot.button(TsUIConstants.getString("btnAdvancedExpanded"));
}
/**
* @return 对话框中的项目树
*/
private SWTBotTree treeProject() {
return dialogBot.tree();
}
/**
* @param prjName
* 项目名称
* @return SWTBotTreeItem 项目所在的树节点
*/
public SWTBotTreeItem treeProject(String prjName) {
return treeProject().getTreeItem(prjName).select();
}
/**
* @param prjName
* 项目名称
* @param type
* 文件类型，即一级目录名称
* @param fileName
* 文件名称
* @return SWTBotTreeItem 文件所在的树节点
*/
public SWTBotTreeItem treeProject(String prjName, String type, String fileName) {
return treeProject().expandNode(prjName, type, fileName).select();
}
/**
* @return SWTBotText 文件夹名文本框
*/
public SWTBotText txtWLblFolderName() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblFolderName"));
}
}
| 2,038 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
PreTranslateResultDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/PreTranslateResultDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.widgets.HsSWTBotTable;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
/**
* 预翻译结果对话框
* @author felix_lu
*/
public class PreTranslateResultDialog extends SWTBotShell {
private SWTBot dlgBot = this.bot();
/**
* 按标题识别对话框
*/
public PreTranslateResultDialog() {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitlePreTransResult")).widget);
}
/**
* @return 表格：预翻译结果列表;
*/
public HsSWTBotTable table() {
return new HsSWTBotTable(dlgBot.table());
}
/**
* @return 列名文本：序号;
*/
public String tblColNum() {
return TsUIConstants.getString("tblColNum2");
}
/**
* @return 列名文本：文件;
*/
public String tblColFile() {
return TsUIConstants.getString("tblColFile");
}
/**
* @return 列名文本：翻译单元个数;
*/
public String tblColTransUnitNum() {
return TsUIConstants.getString("tblColTransUnitNum");
}
/**
* @return 列名文本：已翻译单元;
*/
public String tblColTranslatedUnit() {
return TsUIConstants.getString("tblColTranslatedUnit");
}
/**
* @return 列名文本：锁定上下文匹配;
*/
public String tblColLockedContextMatches() {
return TsUIConstants.getString("tblColLockedContextMatches");
}
/**
* @return 列名文本：锁定完全匹配;
*/
public String tblColLocked100Matches() {
return TsUIConstants.getString("tblColLocked100Matches");
}
/**
* @return 按钮：确定;
*/
public SWTBotButton btnOK() {
return dlgBot.button(TsUIConstants.getString("btnOK"));
}
}
| 1,863 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
MemoryDatabaseManagementDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/MemoryDatabaseManagementDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.widgets.HsSWTBotShell;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotMenu;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 库管理对话框
* @author roy_xiao
*/
public class MemoryDatabaseManagementDialog extends HsSWTBotShell {
/** 对话框模式：管理模式. */
public static final int MANAGEMENT = 0;
/** 对话框模式：选择模式. */
public static final int SELECT = 0;
private SWTBot dialogBot = this.bot();
private int mode;
/**
* 按标题识别对话框
* @param mode
* 对话框模式，请使用本类提供的常量
*/
public MemoryDatabaseManagementDialog(int mode,String title) {
super(HSBot.bot().shell(TsUIConstants.getString(title)).widget);
this.mode = mode;
}
/**
* @return 文本框：服务器地址;
*/
public SWTBotText txtWLblServer() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblServer"));
}
/**
* @return 文本框：服务器端口;
*/
public SWTBotText txtWLblPort() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblPort"));
}
/**
* @return 文本框：服务器实例名称;
*/
public SWTBotText txtWLblInstance() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblInstance"));
}
/**
* @return 文本框：数据库保存路径;
*/
public SWTBotText txtWLblPath() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblPath"));
}
/**
* @return 按钮：浏览;
*/
public SWTBotButton btnBrowse() {
return dialogBot.button(TsUIConstants.getString("btnBrowse"));
}
/**
* @return 文本框：数据库用户名;
*/
public SWTBotText txtWLblUsername() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblUsername"));
}
/**
* @return 文本框：数据库密码;
*/
public SWTBotText txtWLblPassword() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblPassword"));
}
// /**
// * @return 复选框：记住信息;
// */
// public SWTBotCheckBox chkbxRemeber() {
// return dialogBot.checkBox(TsUIConstants.getString("chkbxRemeber"));
// }
/**
* @return 按钮：查询;
*/
public SWTBotButton btnSaveConn() {
return dialogBot.button(TsUIConstants.getString("btnSaveS"));
}
/**
* @return 按钮：查询;
*/
public SWTBotButton btnSearch() {
return dialogBot.button(TsUIConstants.getString("btnSearchS"));
}
/**
* @return 文本：表格列头 编号;
*/
public String tblColNum() {
return TsUIConstants.getString("tblColNum");
}
/**
* @return 文本：表格列头 数据库名称;
*/
public String tblColDatabaseName() {
return TsUIConstants.getString("tblColDatabaseName");
}
/**
* @return 文本：表格列头 语言;
*/
public String tblColLanguage() {
return TsUIConstants.getString("tblColLanguage");
}
/**
* @return 按钮：创建，仅在管理模式下可用;
*/
public SWTBotButton btnCreate() {
assertTrue("参数错误，此功能仅在管理模式下可以使用。", mode == MANAGEMENT);
return dialogBot.button(TsUIConstants.getString("btnCreateN"));
}
/**
* @return 按钮：添加，仅在管理模式下可用;
*/
public SWTBotButton btnAdd() {
assertTrue("参数错误，此功能仅在管理模式下可以使用。", mode == MANAGEMENT);
return dialogBot.button(TsUIConstants.getString("btnAddA"));
}
/**
* @return 按钮：删除，仅在管理模式下可用;
*/
public SWTBotButton btnDelete() {
assertTrue("参数错误，此功能仅在管理模式下可以使用。", mode == MANAGEMENT);
return dialogBot.button(TsUIConstants.getString("btnDeleteD"));
}
/**
* @return 按钮：确定，仅在选择模式下可用;
*/
public SWTBotButton btnOK() {
assertTrue("参数错误，此功能仅在选择模式下可以使用。", mode == SELECT);
return dialogBot.button(TsUIConstants.getString("btnOK"));
}
/**
* @return 按钮：关闭;
*/
public SWTBotButton btnClose() {
return dialogBot.button(TsUIConstants.getString("btnCancel"));
}
/**
* @return 按钮：创建库;
*/
public SWTBotButton btnCreateDb() {
return dialogBot.button(TsUIConstants.getString("btnCreateDb"));
}
/**
* @return 按钮：删除库;
*/
public SWTBotButton btnDeleteDb() {
return dialogBot.button(TsUIConstants.getString("btnDeleteDb"));
}
/**
* @return 按钮：移除连接
*/
public SWTBotButton btnRemoveConn() {
return dialogBot.button(TsUIConstants.getString("btnRemoveR"));
}
/**
* @return 树节点：PostgreSQL;
*/
public SWTBotTreeItem treiDBPostgreSQL() {
return dialogBot.tree().expandNode(TsUIConstants.getString("dbPostgreSQL"));
}
/**
* @return 树节点：MySQL;
*/
public SWTBotTreeItem treiDBMySQL() {
return dialogBot.tree().expandNode(TsUIConstants.getString("dbMySQL"));
}
/**
* @return 树节点：Oracle;
*/
public SWTBotTreeItem treiDBOracle() {
return dialogBot.tree().expandNode(TsUIConstants.getString("dbOracle"));
}
/**
* @return 树节点：InternalDB;
*/
public SWTBotTreeItem treiDBInternal() {
return dialogBot.tree().expandNode(TsUIConstants.getString("dbInternal"));
}
/**
* @return 树节点：DB_MSSQL;
*/
public SWTBotTreeItem treiDBMSSQL() {
return dialogBot.tree().expandNode(TsUIConstants.getString("dbMSSQL"));
}
/**
* @return 右键菜单：删除;
*/
public SWTBotMenu ctxMenuDelete() {
return dialogBot.tree().contextMenu(TsUIConstants.getString("ctxMenuDelete"));
}
}
| 5,880 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
OpenFileDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/OpenFileDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.msgdialogs.InfoFileNotFound;
import net.heartsome.test.swtbot.finders.HsSWTWorkbenchBot;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.waits.IsEditorOpened;
import net.heartsome.test.utilities.sikuli.OsUtil;
import org.eclipse.core.runtime.Path;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotEditor;
/**
* 打开文件对话框
* @author felix_lu
* @version
* @since JDK1.6
*/
public final class OpenFileDialog {
/**
*
*/
private OpenFileDialog() {
}
/**
* 默认文件路径有效
* @param filePath
* 文件路径
*/
public static void openFile(String filePath) {
openFile(filePath, true, true);
}
/**
* 在打开文件对话框中输入指定文件名称或路径
* @param filePath
* 要打开的文件名称或路径
* @param isValid
* 是否为有效文件名称或路径
* @param isFile
* true 表示输入的是文件名称，false 表示文件路径
*/
public static void openFile(String filePath, boolean isValid, boolean isFile) {
OsUtil.typePath(filePath); // typePath 方法处理了多种操作系统的情况
String fileName = new Path(filePath).lastSegment(); // 从路径中取出文件名
if (isValid) {
// 确认编辑器成功打开
HsSWTWorkbenchBot bot = HSBot.bot();
final SWTBotEditor editor = bot.editorByTitle(fileName);
bot.waitUntil(new IsEditorOpened(editor));
} else {
if (isFile) {
// 弹出信息对话框
InfoFileNotFound fnf = new InfoFileNotFound(filePath);
fnf.msgFileNotFound().isVisible(); // 文件未找到
fnf.btnOK().click();
} else {
try {
OsUtil.typeEnter(); // 在系统对话框的信息提示框上点确认
OsUtil.typeEsc(); // 按 Esc 取消打开文件
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
| 1,952 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
NewFileDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/NewFileDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 新建文件向导对话框
* @author felix_lu
* @version
* @since JDK1.6
*/
public class NewFileDialog extends NewWizardDialog {
private SWTBot dialogBot = this.bot();
/**
* 按标题查找对话框
*/
public NewFileDialog() {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitleNewFile")).widget);
}
/**
* @return SWTBotButton 高级 非展开状态
*/
public SWTBotButton btnAdvancedCollapsed() {
return dialogBot.button(TsUIConstants.getString("btnAdvancedCollapsed"));
}
/**
* @return SWTBotButton 高级 展开状态
*/
public SWTBotButton btnAdvancedExpanded() {
return dialogBot.button(TsUIConstants.getString("btnAdvancedExpanded"));
}
/**
* @return 树：项目树
*/
private SWTBotTree treeProject() {
return dialogBot.tree();
}
/**
* @param prjName
* 项目名称
* @return SWTBotTreeItem 项目所在的树节点
*/
public SWTBotTreeItem treeProject(String prjName) {
return treeProject().getTreeItem(prjName).select();
}
/**
* @param prjName
* 项目名称
* @param type
* 文件类型，即一级目录名称
* @param fileName
* 文件名称
* @return SWTBotTreeItem 文件所在的树节点
*/
public SWTBotTreeItem treeProject(String prjName, String type, String fileName) {
return treeProject().expandNode(prjName, type, fileName).select();
}
/**
* @return 文本框：文件名
*/
public SWTBotText txtWLblFileName() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblFileName"));
}
}
| 2,001 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
FileNewDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/FileNewDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 从菜单：文件 > 新建 打开的对话框
* @author felix_lu
* @version
* @since JDK1.6
*/
public class FileNewDialog extends NewWizardDialog {
/** 从右键菜单新建其他打开的对话框标题 */
public static final String NEW = "dlgTitleFileNew";
/** 从右键菜单新建项目打开的对话框标题 */
public static final String NEW_TYPE_PROJECT = "dlgTitleNewProject";
private SWTBot dialogBot = this.bot();
/**
* 根据标题识别对话框
*/
public FileNewDialog(String from) {
super(HSBot.bot().shell(TsUIConstants.getString(from)).widget);
}
/**
* @return SWTBotTreeItem 新建项目
*/
public SWTBotTreeItem treeiProject() {
return dialogBot.tree().getTreeItem(TsUIConstants.getString("treiCreateProject")).select();
}
/**
* @return SWTBotTreeItem 新建记忆库/术语库
*/
public SWTBotTreeItem treeiUntitledTextFile() {
return dialogBot.tree().getTreeItem(TsUIConstants.getString("treiCreateTmTbDB")).select();
}
}
| 1,254 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ImportDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/ImportDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotLabel;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarButton;
/**
* 导入 TMX、TBX 对话框
* @author felix_lu
*/
public class ImportDialog extends SWTBotShell {
public static final String TMX = "dlgTitleImportTMX";
public static final String TBX = "dlgTitleImportTBX";
private SWTBot dialogBot = this.bot();
private String importType;
/**
* 按标题识别对话框
* @param importType
* 导入类型，请使用本类提供的常量
*/
public ImportDialog(String importType) {
super(HSBot.bot().shell(TsUIConstants.getString(importType)).widget);
assertTrue("无此导入类型：" + importType, importType.equals(TMX) || importType.equals(TBX));
this.importType = importType;
}
/**
* @return 文本框：TMX/TBX 文件;
*/
public SWTBotText txtWLblFile() {
if (importType.equals(TMX)) {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblTMXFile"));
}
else {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblTBXFile"));
}
}
/**
* @return 文本框：数据库;
*/
public SWTBotText txtWLblDatabase() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblDatabase"));
}
/**
* @return 按钮：浏览;
*/
public SWTBotButton btnBrowse() {
return dialogBot.button(TsUIConstants.getString("btnBrowseB"));
}
/**
* @return 按钮：选择库;
*/
public SWTBotButton btnSelectDB() {
return dialogBot.button(TsUIConstants.getString("btnSelectDB"));
}
/**
* @return 按钮：设置;
*/
public SWTBotButton btnSetting() {
return dialogBot.button(TsUIConstants.getString("btnSetting"));
}
/**
* @return 按钮：完成;
*/
public SWTBotButton btnFinish() {
return dialogBot.button(TsUIConstants.getString("btnFinish"));
}
/**
* @return 按钮：取消;
*/
public SWTBotButton btnCancel() {
return dialogBot.button(TsUIConstants.getString("btnCancel"));
}
/**
* @return 文本信息：导入成功;
*/
public SWTBotText msgImportSuccess() {
return dialogBot.text(TsUIConstants.getString("txtImportSuccess"));
}
/**
* @return 文本信息：提示选择要导入的文件;
*/
public SWTBotText msgNoFileToImport() {
return dialogBot.text(TsUIConstants.getString("txtNoFileToImport"));
}
/**
* @return 文本信息：提示选择要导入的库;
*/
public SWTBotText msgNoDBToImport() {
return dialogBot.text(TsUIConstants.getString("txtNoDBToImport"));
}
/**
* @return 文本信息：提示文件错误;
*/
public SWTBotText msgFileError() {
if (importType.equals(TMX)) {
return dialogBot.text(TsUIConstants.getString("txtTMXFileError"));
} else {
return dialogBot.text(TsUIConstants.getString("txtTBXFileError"));
}
}
/**
* @return 文字标签：正在导入 TYPE_TMX/TYPE_TBX 文件;
*/
public SWTBotLabel msgImporting() {
if (importType.equals(TMX)) {
return dialogBot.label(TsUIConstants.getString("lblImportingTMX"));
} else {
return dialogBot.label(TsUIConstants.getString("lblImportingTBX"));
}
}
/**
* @return 工具栏按钮：取消操作;
*/
public SWTBotToolbarButton tlbBtnWTltCancelOperation() {
return dialogBot.toolbarButtonWithTooltip(TsUIConstants.getString("tlbBtnWTltCancelOperation"));
}
/**
* @return 文本信息：用户取消了导入操作;
*/
public SWTBotText msgCancelImport() {
if (importType.equals(TMX)) {
return dialogBot.text(TsUIConstants.getString("txtCancelImportTMX"));
} else {
return dialogBot.text(TsUIConstants.getString("txtCancelImportTBX"));
}
}
}
| 4,026 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
PreTranslateDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/PreTranslateDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.widgets.HsSWTBotTable;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotCheckBox;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
/**
* 预翻译对话框
* @author felix_lu
*/
public class PreTranslateDialog extends SWTBotShell {
private SWTBot dlgBot = this.bot();
/**
* 按标题识别对话框
*/
public PreTranslateDialog() {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitlePreTranslation")).widget);
}
/**
* @return 表格：预翻译文件列表;
*/
public HsSWTBotTable table() {
return new HsSWTBotTable(dlgBot.table());
}
/**
* @return 列名文本：序号;
*/
public String tblColNum() {
return TsUIConstants.getString("tblColNum2");
}
/**
* @return 列名文本：文件;
*/
public String tblColFile() {
return TsUIConstants.getString("tblColFile");
}
/**
* @return 列名文本：源语言;
*/
public String tblColSrcLang() {
return TsUIConstants.getString("tblColSrcLang");
}
/**
* @return 列名文本：目标语言;
*/
public String tblColTgtLang() {
return TsUIConstants.getString("tblColTgtLang");
}
/**
* @return 复选框：是否锁定完全匹配
*/
public SWTBotCheckBox chkbxLock100Matches() {
return dlgBot.checkBox(TsUIConstants.getString("chkbxLock100Matches"));
}
/**
* @return 复选框：是否锁定上下文匹配
*/
public SWTBotCheckBox chkbxLockContextMatches() {
return dlgBot.checkBox(TsUIConstants.getString("chkbxLockContextMatches"));
}
/**
* @return 按钮：参数设置;
*/
public SWTBotButton btnPreferencesSetting() {
return dlgBot.button(TsUIConstants.getString("btnPreferencesSetting"));
}
/**
* @return 按钮：取消;
*/
public SWTBotButton btnCancel() {
return dlgBot.button(TsUIConstants.getString("btnCancelC"));
}
/**
* @return 按钮：确定;
*/
public SWTBotButton btnOK() {
return dlgBot.button(TsUIConstants.getString("btnOKO"));
}
}
| 2,225 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
TS.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/TS.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.editors.XlfEditor;
import net.heartsome.cat.ts.test.ui.tasks.TsTasks;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeItem;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import net.heartsome.test.swtbot.finders.HsSWTWorkbenchBot;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotEditor;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotPerspective;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotMenu;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarButton;
/**
* Translation Studio 程序的主界面，单例模式
*
* @author felix_lu
* @version
* @since JDK1.6
*/
public final class TS extends SWTBotShell {
private static HsSWTWorkbenchBot bot = HSBot.bot();
private static TS ts;
/**
* @param shell
*/
private TS(SWTBotShell shell) {
super(shell.widget);
}
/**
* @return 当前的 TS 主界面实例;
*/
public static TS getInstance() {
if (ts == null) {
ts = new TS(bot.shell(TsUIConstants.getString("TsTitle")));
}
return ts;
}
/* ************ 工具栏按钮 ************ */
/**
* @return 工具栏按钮：改变编辑器布局;
*/
public SWTBotToolbarButton tlbBtnWTltChangeEditorLayout() {
return bot.toolbarButton(TsUIConstants
.getString("tlbBtnWTltChangeEditorLayout"));
}
/* ************ 状态栏 ************ */
/**
* 读取编辑器未获取焦点时状态栏中的信息
*/
public String getStatusBarText() {
// TODO 需要考虑增加其他标识以提高 CLabel 的识别准确性
return bot.clabel().getText();
}
/**
* 解析编辑器获取焦点时状态栏中的信息，根据传入的 Key 取得其在状态栏中的值
*/
public String getStatusBarValueByKey(String statusBarKey) {
// TODO 需要考虑增加其他标识以提高 CLabel 的识别准确性
String text = bot.clabel().getText();
String groupSign = TsUIConstants.getString("stbGroupSign");
String delimiter = TsUIConstants.getString("stbDelimiter");
return TsTasks.getStatusValueByKey(text, groupSign, delimiter,
statusBarKey);
}
/**
* 取得状态栏“当前文件”文字标签
*
* @return String 状态栏“当前文件”文字标签
*/
public String stbiCurrentFile() {
return getStatusBarValueByKey(TsUIConstants
.getString("stbiCurrentFile"));
}
/**
* 取得状态栏“顺序号”文字标签
*
* @return String 状态栏“顺序号”文字标签
*/
public String stbiSegmentNumber() {
return getStatusBarValueByKey(TsUIConstants
.getString("stbiSegmentNumber"));
}
/**
* 取得状态栏“可见文本段数”文字标签
*
* @return String 状态栏“可见文本段数”文字标签
*/
public String stbiVisibleSegmentCount() {
return getStatusBarValueByKey(TsUIConstants
.getString("stbiVisibleSegmentCount"));
}
/**
* 取得状态栏“文本段总数”文字标签
*
* @return String 状态栏“文本段总数”文字标签
*/
public String stbiSegmentTotalCount() {
return getStatusBarValueByKey(TsUIConstants
.getString("stbiSegmentTotalCount"));
}
/**
* 取得状态栏“用户名”文字标签
*
* @return String 状态栏“用户名”文字标签
*/
public String stbiUsername() {
return getStatusBarValueByKey(TsUIConstants.getString("stbiUsername"));
}
/* ************ 透视图 ************ */
/**
* @return 透视图：默认布局;
*/
public SWTBotPerspective psptvBtnDefault() {
return bot.perspectiveByLabel(TsUIConstants
.getString("psptvBtnDefault"));
}
/* ************ 常用操作 ************ */
/**
* 激活或打开编辑器，仅限合并打开的指定项目中的 XLIFF 文件
*
* @param prjName
* 要打开的项目名称
*/
public void setCurrentFile(String prjName) {
SWTBotEditor editor = bot.editorByTitle(prjName);
if (editor != null) {
editor.show();
} else {
ProjectTreeItem.getInstance(prjName).ctxMenuOpenProjectFiles();
}
// TODO: 需要完善对同名编辑器的判断和处理
}
/**
* 激活或打开编辑器，仅限项目 XLIFF 目录中的 XLIFF 文件
*
* @param prjName
* XLIFF 文件所在的项目名称
* @param xlfFileName
* 要打开的 XLIFF 文件名称
*/
public void setCurrentFile(String prjName, String xlfFileName) {
SWTBotEditor editor = bot.editorByTitle(xlfFileName);
if (editor != null) {
editor.show();
} else {
ProjectTreeView.doubleClickXlfFile(prjName, xlfFileName);
}
// TODO: 需要完善对同名编辑器的判断和处理
}
/* ************ 编辑器 ************ */
/**
* 不指定文件名时，取得当前激活的编辑器
*
* @return XlfEditor 当前激活的编辑器
*/
public XlfEditor getXlfEditor() {
return new XlfEditor(bot.activeEditor());
}
/**
* 得到指定文件名所在的编辑器
*
* @param fileName
* 指定的文件名
* @return XlfEditor 得到的编辑器
*/
public XlfEditor getXlfEditor(String fileName) {
SWTBotEditor editor = bot.editorByTitle(fileName);
editor.show();
return new XlfEditor(editor);
}
/* ************ 菜单项 ************ */
/**
* 文件菜单
*/
public SWTBotMenu menuFile() {
return bot.menu(TsUIConstants.getString("menuFile"));
}
/**
* @return 菜单：文件 > 新建;
*/
public SWTBotMenu menuFileNew() {
return menuFile().menu(TsUIConstants.getString("menuFileNew"));
}
/**
* @return 菜单：文件 > 新建 > 项目...;
*/
public SWTBotMenu menuFileNewProject() {
return menuFileNew()
.menu(TsUIConstants.getString("menuFileNewProject"));
}
/**
* @return 菜单：文件 > 打开;
*/
public SWTBotMenu menuFileOpenFile() {
return menuFile().menu(TsUIConstants.getString("menuFileOpenFile"));
}
/**
* @return 菜单：文件 > 关闭;
*/
public SWTBotMenu menuFileClose() {
return menuFile().menu(TsUIConstants.getString("menuFileClose"));
}
/**
* @return 菜单：文件 > 关闭所有;
*/
public SWTBotMenu menuFileCloseAll() {
return menuFile().menu(TsUIConstants.getString("menuFileCloseAll"));
}
/**
* @return 菜单：文件 > 保存;
*/
public SWTBotMenu menuFileSave() {
return menuFile().menu(TsUIConstants.getString("menuFileSave"));
}
/**
* @return 菜单：文件 > 另存为;
*/
public SWTBotMenu menuFileSaveAs() {
return menuFile().menu(TsUIConstants.getString("menuFileSaveAs"));
}
/**
* @return 菜单：文件 > 保存所有;
*/
public SWTBotMenu menuFileSaveAll() {
return menuFile().menu(TsUIConstants.getString("menuFileSaveAll"));
}
/**
* @return 菜单：文件 > 退出;
*/
public SWTBotMenu menuFileExit() {
return menuFile().menu(TsUIConstants.getString("menuFileExit"));
}
/**
* 编辑菜单 // TODO
*
* @return
*/
public SWTBotMenu menuEdit() {
return bot.menu(TsUIConstants.getString("menuEdit"));
}
/**
* @return 菜单：编辑 > 删除;
*/
public SWTBotMenu menuEditDelete() {
return menuEdit().menu(TsUIConstants.getString("menuEditDelete"));
}
/**
* 查看菜单
*/
public SWTBotMenu menuView() {
return bot.menu(TsUIConstants.getString("menuView"));
}
/**
* @return 菜单：查看 > TM 匹配面板;
*/
public SWTBotMenu menuViewTMMatchesPanel() {
return menuView().menu(
TsUIConstants.getString("menuViewTMMatchesPanel"));
}
/**
* @return 菜单：查看 > 快译面板;
*/
public SWTBotMenu menuViewQuickTranslationPanel() {
return menuView().menu(
TsUIConstants.getString("menuViewQuickTranslationPanel"));
}
/**
* @return 菜单：查看 > 批注面板;
*/
public SWTBotMenu menuViewNotesPanel() {
return menuView().menu(TsUIConstants.getString("menuViewNotesPanel"));
}
/**
* @return 菜单：查看 > 术语面板;
*/
public SWTBotMenu menuViewTerminologyPanel() {
return menuView().menu(
TsUIConstants.getString("menuViewTerminologyPanel"));
}
/**
* @return 菜单：查看 > 文档属性;
*/
public SWTBotMenu menuViewDocumentPropertiesPanel() {
return menuView().menu(
TsUIConstants.getString("menuViewDocumentPropertiesPanel"));
}
/**
* 数据库菜单 // TODO
*/
public SWTBotMenu menuDB() {
return bot.menu(TsUIConstants.getString("menuDB"));
}
/**
* @return 菜单：数据库 > 记忆库管理;
*/
public SWTBotMenu menuDBManagement() {
return menuDB().menu(TsUIConstants.getString("menuDBManagement"));
}
/**
* @return 菜单：数据库 > 术语库管理;
*/
public SWTBotMenu menuTeriDBManagement() {
return menuDB().menu(TsUIConstants.getString("menuTeriDBManagement"));
}
/**
* @return 菜单：数据库 > 导入 TMX;
*/
public SWTBotMenu menuDBImportTMXFile() {
return menuDB().menu(TsUIConstants.getString("menuDBImportTMXFile"));
}
/**
* @return 菜单：数据库 > 导出 TMX;
*/
public SWTBotMenu menuDBExportAsTMX() {
return menuDB().menu(TsUIConstants.getString("menuDBExportAsTMX"));
}
/**
* @return 菜单：数据库 > 导入 TBX;
*/
public SWTBotMenu menuDBImportTBXFile() {
return menuDB().menu(TsUIConstants.getString("menuDBImportTBXFile"));
}
/**
* @return 菜单：数据库 > 导出 TBX;
*/
public SWTBotMenu menuDBExportAsTBX() {
return menuDB().menu(TsUIConstants.getString("menuDBExportAsTBX"));
}
//
// /**
// * @return 菜单：数据库 > 生成 CSV 模板;
// */
// public SWTBotMenu menuDBCSVTemplate() {
// return menuDB().menu(TsUIConstants.getString("menuDBCSVTemplate"));
// }
//
// /**
// * @return 菜单：数据库 > 导入 CSV 文件;
// */
// public SWTBotMenu menuDBImportCSVFile() {
// return menuDB().menu(TsUIConstants.getString("menuDBImportCSVFile"));
// }
//
// /**
// * @return 菜单：数据库 > 导出 CSV 文件;
// */
// public SWTBotMenu menuDBExportAsCSVFile() {
// return menuDB().menu(TsUIConstants.getString("menuDBExportAsCSVFile"));
// }
/**
* 工具菜单 // TODO
*/
/**
* 翻译菜单 // TODO
*/
public SWTBotMenu menuTranslation() {
return bot.menu(TsUIConstants.getString("menuTranslation"));
}
/**
* @return 菜单项：翻译 > 预翻译;
*/
public SWTBotMenu menuTranslationPreTrans() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationPreTrans"));
}
/**
* @return 菜单项：翻译 > 复制来源到目标;
*/
public SWTBotMenu menuTranslationCopySourceToTarget() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationCopySourceToTarget"));
}
/**
* @return 菜单项：翻译 > 搜索术语库;
*/
public SWTBotMenu menuTranslationSearchTermDB() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationSearchTermDB"));
}
/**
* @return 菜单项：翻译 > 相关搜索;
*/
public SWTBotMenu menuTranslationSearchTMDB() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationSearchTMDB"));
}
/**
* @return 菜单项：翻译 > 添加术语到术语库;
*/
public SWTBotMenu menuTranslationAddToTermDB() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationAddToTermDB"));
}
/**
* @return 菜单项：翻译 > 添加选中文本段到记忆库;
*/
public SWTBotMenu menuTranslationAddToTM() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationAddToTM"));
}
/**
* @return 菜单项：翻译 > 添加到记忆库并跳转到下一文本段;
*/
public SWTBotMenu menuTranslationAddToTMAndNext() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationAddToTMAndNext"));
}
/**
* @return 菜单项：翻译 > 添加到记忆库并跳转到下一非完全匹配;
*/
public SWTBotMenu menuTranslationAddToTMAndNextNon100Match() {
return menuTranslation().menu(
TsUIConstants
.getString("menuTranslationAddToTMAndNextNon100Match"));
}
/**
* @return 菜单项：翻译 > 批准文本段;
*/
public SWTBotMenu menuTranslationApproveSegment() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationApproveSegment"));
}
/**
* @return 菜单项：翻译 > 锁定文本段;
*/
public SWTBotMenu menuTranslationLockSegment() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationLockSegment"));
}
/**
* @return 菜单项：翻译 > 锁定重复文本段;
*/
public SWTBotMenu menuTranslationLockRepetition() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationLockRepetition"));
}
/**
* @return 菜单项：翻译 > 分割文本段;
*/
public SWTBotMenu menuTranslationSplitSegment() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationSplitSegment"));
}
/**
* @return 菜单项：翻译 > 合并文本段;
*/
public SWTBotMenu menuTranslationMergeSegments() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationMergeSegments"));
}
/**
* @return 菜单项：翻译 > 删除译文;
*/
public SWTBotMenu menuTranslationDeleteTranslation() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationDeleteTranslation"));
}
/**
* @return 菜单项：翻译 > 删除批注;
*/
public SWTBotMenu menuTranslationDeleteNotes() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationDeleteNotes"));
}
/**
* @return 菜单项：翻译 > 删除匹配;
*/
public SWTBotMenu menuTranslationDeleteMatches() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationDeleteMatches"));
}
/**
* @return 菜单项：翻译 > 执行快速翻译;
*/
public SWTBotMenu menuTranslationQuickTranslate() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationQuickTranslate"));
}
/**
* @return 菜单项：翻译 > 执行繁殖翻译;
*/
public SWTBotMenu menuTranslationPropagateTranslate() {
return menuTranslation().menu(
TsUIConstants.getString("menuTranslationPropagateTranslate"));
}
// /**
// * @return 菜单：翻译 > 接受所有文本段的 100％ 匹配;
// */
// public SWTBotMenu menuTranslationAccept100MatchesForAllSegments() {
// return
// menuTranslation().menu(TsUIConstants.getString("menuTranslationAccept100MatchesForAllSegments"));
// }
//
// /**
// * @return 菜单：翻译 > 接受并批准所有文本段的 100％ 匹配;
// */
// public SWTBotMenu
// menuTranslationAcceptAndApprove100MatchesForAllSegments() {
// return
// menuTranslation().menu(TsUIConstants.getString("menuTranslationAcceptAndApprove100MatchesForAllSegments"));
// }
//
// /**
// * @return 菜单：翻译 > 接受所有文本段的 101％ 匹配;
// */
// public SWTBotMenu menuTranslationAccept101MatchesForAllSegments() {
// return
// menuTranslation().menu(TsUIConstants.getString("menuTranslationAccept101MatchesForAllSegments"));
// }
//
// /**
// * @return 菜单：翻译 > 接受并批准所有文本段的 101％ 匹配;
// */
// public SWTBotMenu
// menuTranslationAcceptAndApprove101MatchesForAllSegments() {
// return
// menuTranslation().menu(TsUIConstants.getString("menuTranslationAcceptAndApprove101MatchesForAllSegments"));
// }
/**
* 品质检查菜单 // TODO
*/
/**
* 项目菜单 // TODO
*/
public SWTBotMenu menuProject() {
return bot.menu(TsUIConstants.getString("menuProject"));
}
/**
* @return 菜单：项目 > 项目设置;
*/
public SWTBotMenu menuProjectSetting() {
return menuProject()
.menu(TsUIConstants.getString("menuProjectSetting"));
}
/**
* @return 菜单：项目 > 文件分析 > 字数分析;
*/
public SWTBotMenu menuProjectWordCount() {
return menuProject().menu(
TsUIConstants.getString("menuProjectFileAnalysis")).menu(
TsUIConstants.getString("menuProjectWordCount"));
}
/**
* @return 菜单：项目 > 文件分析 > 翻译进度分析;
*/
public SWTBotMenu menuProjectTransProgress() {
return menuProject().menu(
TsUIConstants.getString("menuProjectFileAnalysis")).menu(
TsUIConstants.getString("menuProjectTransProgress"));
}
/**
* @return 菜单：项目 > 文件分析 > 编辑进度分析;
*/
public SWTBotMenu menuProjectEditProgress() {
return menuProject().menu(
TsUIConstants.getString("menuProjectFileAnalysis")).menu(
TsUIConstants.getString("menuProjectEditProgress"));
}
/**
* @return 菜单：项目 > 更新记忆库;
*/
public SWTBotMenu menuProjectUpdateTM() {
return menuProject().menu(
TsUIConstants.getString("menuProjectUpdateTM"));
}
/**
* 帮助菜单 // TODO
*/
}
| 16,812 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
NewWizardDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/NewWizardDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.widgets.HsSWTBotShell;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.hamcrest.SelfDescribing;
/**
* 新建...向导对话框
* @author felix_lu
*/
public class NewWizardDialog extends HsSWTBotShell {
private SWTBot dialogBot = this.bot();
/**
* @param shell
*/
public NewWizardDialog(Shell shell) {
super(shell);
}
/**
* @param shell
* @param description
*/
public NewWizardDialog(Shell shell, SelfDescribing description) {
super(shell, description);
}
/**
* @return SWTBotButton 上一步
*/
public SWTBotButton btnBack() {
return dialogBot.button(TsUIConstants.getString("btnBack"));
}
/**
* @return SWTBotButton 取消
*/
public SWTBotButton btnCancel() {
return dialogBot.button(TsUIConstants.getString("btnCancel"));
}
/**
* @return SWTBotButton 完成
*/
public SWTBotButton btnFinish() {
return dialogBot.button(TsUIConstants.getString("btnFinish"));
}
/**
* @return SWTBotButton 下一步
*/
public SWTBotButton btnNext() {
return dialogBot.button(TsUIConstants.getString("btnNext"));
}
}
| 1,314 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
DatabaseManagementDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/DatabaseManagementDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.widgets.HsSWTBotShell;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotCheckBox;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotMenu;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 库管理对话框
* @author felix_lu
*/
public class DatabaseManagementDialog extends HsSWTBotShell {
/** 对话框模式：管理模式. */
public static final int MANAGEMENT = 0;
/** 对话框模式：选择模式. */
public static final int SELECT = 1;
private SWTBot dialogBot = this.bot();
private int mode;
/**
* 按标题识别对话框
* @param mode
* 对话框模式，请使用本类提供的常量
*/
public DatabaseManagementDialog(int mode) {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitleDatabaseManagement")).widget);
this.mode = mode;
}
/**
* @return 文本框：服务器地址;
*/
public SWTBotText txtWLblServer() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblServer"));
}
/**
* @return 文本框：服务器端口;
*/
public SWTBotText txtWLblPort() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblPort"));
}
/**
* @return 文本框：服务器实例名称;
*/
public SWTBotText txtWLblInstance() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblInstance"));
}
/**
* @return 文本框：数据库保存路径;
*/
public SWTBotText txtWLblPath() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblPath"));
}
/**
* @return 按钮：浏览;
*/
public SWTBotButton btnBrowse() {
return dialogBot.button(TsUIConstants.getString("btnBrowse"));
}
/**
* @return 文本框：数据库用户名;
*/
public SWTBotText txtWLblUsername() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblUsername"));
}
/**
* @return 文本框：数据库密码;
*/
public SWTBotText txtWLblPassword() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblPassword"));
}
/**
* @return 复选框：记住信息;
*/
public SWTBotCheckBox chkbxRemeber() {
return dialogBot.checkBox(TsUIConstants.getString("chkbxRemeber"));
}
/**
* @return 按钮：查询;
*/
public SWTBotButton btnSearch() {
return dialogBot.button(TsUIConstants.getString("btnSearch"));
}
/**
* @return 文本：表格列头 编号;
*/
public String tblColNum() {
return TsUIConstants.getString("tblColNum");
}
/**
* @return 文本：表格列头 数据库名称;
*/
public String tblColDatabaseName() {
return TsUIConstants.getString("tblColDatabaseName");
}
/**
* @return 文本：表格列头 语言;
*/
public String tblColLanguage() {
return TsUIConstants.getString("tblColLanguage");
}
/**
* @return 按钮：创建，仅在管理模式下可用;
*/
public SWTBotButton btnCreate() {
assertTrue("参数错误，此功能仅在管理模式下可以使用。", mode == MANAGEMENT);
return dialogBot.button(TsUIConstants.getString("btnCreateN"));
}
/**
* @return 按钮：删除，仅在管理模式下可用;
*/
public SWTBotButton btnDelete() {
assertTrue("参数错误，此功能仅在管理模式下可以使用。", mode == MANAGEMENT);
return dialogBot.button(TsUIConstants.getString("btnDeleteD"));
}
/**
* @return 按钮：确定，仅在选择模式下可用;
*/
public SWTBotButton btnOK() {
assertTrue("参数错误，此功能仅在选择模式下可以使用。", mode == SELECT);
return dialogBot.button(TsUIConstants.getString("btnOKO"));
}
/**
* @return 按钮：关闭;
*/
public SWTBotButton btnClose() {
return dialogBot.button(TsUIConstants.getString("btnCloseC"));
}
/**
* @return 树节点：PostgreSQL;
*/
public SWTBotTreeItem treiDBPostgreSQL() {
return dialogBot.tree().expandNode(TsUIConstants.getString("dbPostgreSQL"));
}
/**
* @return 树节点：MySQL;
*/
public SWTBotTreeItem treiDBMySQL() {
return dialogBot.tree().expandNode(TsUIConstants.getString("dbMySQL"));
}
/**
* @return 树节点：Oracle;
*/
public SWTBotTreeItem treiDBOracle() {
return dialogBot.tree().expandNode(TsUIConstants.getString("dbOracle"));
}
/**
* @return 树节点：InternalDB;
*/
public SWTBotTreeItem treiDBInternal() {
return dialogBot.tree().expandNode(TsUIConstants.getString("dbInternal"));
}
/**
* @return 树节点：DB_MSSQL;
*/
public SWTBotTreeItem treiDBMSSQL() {
return dialogBot.tree().expandNode(TsUIConstants.getString("dbMSSQL"));
}
/**
* @return 右键菜单：删除;
*/
public SWTBotMenu ctxMenuDelete() {
return dialogBot.tree().contextMenu(TsUIConstants.getString("ctxMenuDelete"));
}
}
| 5,049 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
NewProjectDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/NewProjectDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import static org.junit.Assert.assertTrue;
import java.text.MessageFormat;
import java.util.List;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.finders.HsSWTBot;
import net.heartsome.test.swtbot.widgets.SWTBotTableCombo;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotLabel;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotList;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTable;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
/**
* @author felix_lu
* @version
* @since JDK1.6
*/
public class NewProjectDialog extends FileNewDialog {
private HsSWTBot dialogBot = this.bot();
/**
* 先打开新建向导对话框
*/
public NewProjectDialog(String newType) {
super(newType);
}
/*****************************************
* 常用方法
*****************************************/
/**
* @param name
* @param remark
* @param client
* @param company
* @param email
*/
public void setBasicInfo(String name, String remark, String client, String company, String eMail) {
assertTrue("项目名称不能为 null。", name != null);
setName(name);
if (remark != null) {
setRemark(remark);
}
if (client != null) {
setClient(client);
}
if (company != null) {
setCompany(company);
}
if (eMail != null) {
setEMail(eMail);
}
}
/**
* @param basicInfo 字符串数组：项目基本信息，按照界面顺序依次为项目名称、备注、客户、公司、邮箱。
*/
public void setBasicInfo(String[] basicInfo) {
assertTrue("项目基本信息参数不正确。", basicInfo.length == 5);
assertTrue("项目名称不能为 null。", basicInfo[0] != null);
setName(basicInfo[0]);
if (basicInfo[1] != null) {
setRemark(basicInfo[1]);
}
if (basicInfo[2] != null) {
setClient(basicInfo[2]);
}
if (basicInfo[3] != null) {
setCompany(basicInfo[3]);
}
if (basicInfo[4] != null) {
setEMail(basicInfo[4]);
}
}
/**
* @param srcLangCode
* @param tgtLangCodes ;
*/
public void setLangPair(String srcLangCode, String... tgtLangCodes) {
assertTrue("源语言代码不能为空或 null。", !(srcLangCode == null || "".equals(srcLangCode)));
setSrcLang(srcLangCode);
assertTrue("目标语言语言不能为空或 null。", tgtLangCodes.length > 0);
for (int i = 0; i < tgtLangCodes.length; i++) {
assertTrue("目标语言语言不能为空或 null。", !(tgtLangCodes[i] == null || "".equals(tgtLangCodes[i])));
}
setTgtLang(tgtLangCodes);
}
/**
* @param srcLangCode
* @param tgtLangCodes ;
*/
public void setLangPair(String srcLangCode, List<String> tgtLangCodes) {
assertTrue("源语言代码不能为空或 null。", !(srcLangCode == null || "".equals(srcLangCode)));
setSrcLang(srcLangCode);
assertTrue("目标语言语言不能为空或 null。", tgtLangCodes.size() > 0);
for (String tgtLangCode : tgtLangCodes) {
assertTrue("目标语言语言不能为空或 null。", !(tgtLangCode == null || "".equals(tgtLangCode)));
}
setTgtLang(tgtLangCodes);
}
/**
* 断言对话框标题是否符合预期;
*/
public void isTitleCreateProject() {
assertTrue("创建项目向导对话框的标题不正确。", getText().equals(TsUIConstants.getString("dlgTitleCreateProject")));
}
/**
* 断言对话框标题是否符合预期（从菜单、快捷键及右键新建其他）;
*/
public void isTitleNew() {
assertTrue("新建向导对话框的标题不正确。", getText().equals(TsUIConstants.getString("dlgTitleFileNew")));
}
/**
* 断言对话框标题是否符合预期（从右键新建项目）;
*/
public void isTitleNewProject() {
assertTrue("新建项目向导对话框的标题不正确。", getText().equals(TsUIConstants.getString("dlgTitleFileNewProject")));
}
/**
* @param name ;
*/
public void setName(String name) {
txtWLblProjectName().setText(name);
}
/**
* @param prjRemark ;
*/
public void setRemark(String prjRemark) {
txtWLblRemark().setText(prjRemark);
}
/**
* @param prjClient ;
*/
public void setClient(String prjClient) {
txtWLblClient().setText(prjClient);
}
/**
* @param prjCompany ;
*/
public void setCompany(String prjCompany) {
txtWLblCompany().setText(prjCompany);
}
/**
* @param eMail ;
*/
public void setEMail(String eMail) {
txtWLblEMail().setText(eMail);
}
/**
* @param srcLangCode ;
*/
public void setSrcLang(String srcLangCode) {
String srcLang = TsUIConstants.getLang(srcLangCode);
cmbSourceLang().setSelection(srcLang);
assertTrue("源语言设置失败。", srcLang.equals(cmbSourceLang().selection()));
}
/**
* @param tgtLangCodes ;
*/
public void setTgtLang(String... tgtLangCodes) {
String[] tgtLangs = TsUIConstants.getLangs(tgtLangCodes);
tabTargetLangAvailable().select(tgtLangs);
btnAddToRight().click();
for (int i = 0; i < tgtLangs.length; i++) {
assertTrue("目标语言设置失败：" + tgtLangs[i], tabTargetLangSelected().indexOf(tgtLangs[i]) != -1);
}
}
/**
* @param tgtLangCodes ;
*/
public void setTgtLang(List<String> tgtLangCodes) {
String[] langs = new String[tgtLangCodes.size()];
tgtLangCodes.toArray(langs);
setTgtLang(langs);
}
/**
* @param tgtLangCodes ;
*/
public void rmTgtLang(String... tgtLangCodes) {
assertTrue("目标语言语言不能为空或 null。", tgtLangCodes.length > 0);
for (int i = 0; i < tgtLangCodes.length; i++) {
assertTrue("目标语言语言不能为空或 null。", !(tgtLangCodes[i] == null || "".equals(tgtLangCodes[i])));
}
String[] tgtLangs = TsUIConstants.getLangs(tgtLangCodes);
for (int i = 0; i < tgtLangs.length; i++) {
assertTrue("该目标语言代码对应的语言未添加到已选列表：" + tgtLangCodes[i], tabTargetLangSelected().indexOf(tgtLangs[i]) != -1);
}
tabTargetLangSelected().select(tgtLangs);
btnDeleteToLeft().click();
for (int i = 0; i < tgtLangs.length; i++) {
assertTrue("目标语言删除失败：" + tgtLangs[i], tabTargetLangSelected().indexOf(tgtLangs[i]) == -1);
}
}
/**
* ;
*/
public void rmAllTgtLang() {
btnDeleteAll().click();
assertTrue("目标语言删除失败。", tabTargetLangSelected().rowCount() == 0);
}
/*****************************************
* 界面元素映射
*****************************************/
/**
* @return 第 1 页：项目信息;
*/
public SWTBotLabel lblProjectInfo() {
return dialogBot.label(TsUIConstants.getString("lblProjectInfo"));
}
/**
* @return 文本框：项目名
*/
public SWTBotText txtWLblProjectName() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblProjectName"));
}
/**
* @return 文本框：备注
*/
public SWTBotText txtWLblRemark() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblProjectRemark"));
}
/**
* @return 文本框：客户
*/
public SWTBotText txtWLblClient() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblProjectClient"));
}
/**
* @return 文本框：公司
*/
public SWTBotText txtWLblCompany() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblProjectCompany"));
}
/**
* @return 文本框：电子邮箱
*/
public SWTBotText txtWLblEMail() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblProjectEMail"));
}
/**
* @return 文本：项目名称重复
*/
public SWTBotText msgDucplicatedProjectName() {
return dialogBot.text(TsUIConstants.getString("msgDucplicatedProjectName"));
}
/**
* @return 文本：项目名称含非法字符
*/
public SWTBotText msgInvalidCharInResourceName(String invalidChar, String resourceName) {
String msg = TsUIConstants.getString("msgInvalidCharInResourceName");
return dialogBot.text(MessageFormat.format(msg, invalidChar, resourceName));
}
/**
* @return 第 2 页：语言对设置;
*/
public SWTBotLabel lblLangSetting() {
return dialogBot.label(TsUIConstants.getString("lblLangSetting"));
}
/**
* @return 下拉列表：源语言
*/
public SWTBotTableCombo cmbSourceLang() {
return dialogBot.tableCombo();
}
/**
* @return 表格：可供选择的目标语言
*/
public SWTBotTable tabTargetLangAvailable() {
return dialogBot.table(0);
}
/**
* @return 表格：已选择的目标语言
*/
public SWTBotTable tabTargetLangSelected() {
return dialogBot.table(1);
}
/**
* @return 按钮：添加目标语言
*/
public SWTBotButton btnAddToRight() {
return dialogBot.button(TsUIConstants.getString("btnAddToRight"));
}
/**
* @return 按钮：删除目标语言
*/
public SWTBotButton btnDeleteToLeft() {
return dialogBot.button(TsUIConstants.getString("btnDeleteToLeft"));
}
/**
* @return 按钮：删除所有目标语言
*/
public SWTBotButton btnDeleteAll() {
return dialogBot.button(TsUIConstants.getString("btnDeleteAll"));
}
/**
* @return 第 3 页：记忆库设置;
*/
public SWTBotLabel lblTmSetting() {
return dialogBot.label(TsUIConstants.getString("lblTmSetting"));
}
/**
* @return ;
*/
public SWTBotTable tblTMDB() {
return dialogBot.table();
}
/**
* @return ;
*/
public SWTBotButton btnAdd() {
return dialogBot.button(TsUIConstants.getString("btnAddA"));
}
/**
* @return ;
*/
public SWTBotButton btnCreate() {
return dialogBot.button(TsUIConstants.getString("btnCreate"));
}
/**
* @return ;
*/
public SWTBotButton btnDelete() {
return dialogBot.button(TsUIConstants.getString("btnDeleteD"));
}
/**
* @return ;
*/
public SWTBotButton btnImportTMX() {
return dialogBot.button(TsUIConstants.getString("btnImportTMX"));
}
/**
* @return ;
*/
public SWTBotLabel lblTbSetting() {
return dialogBot.label(TsUIConstants.getString("lblTbSetting"));
}
/**
* @return 第 4 页：术语库设置;
*/
public SWTBotTable tblTBDB() {
return dialogBot.table();
}
/**
* @return ;
*/
public SWTBotButton btnImportTBX() {
return dialogBot.button(TsUIConstants.getString("btnImportTBX"));
}
/**
* @return 第 5 页：添加源文件;
*/
public SWTBotLabel lblAddSrcFile() {
return dialogBot.label(TsUIConstants.getString("lblAddSrcFile"));
}
/**
* @return ;
*/
public SWTBotList lstSrcFile() {
return dialogBot.list();
}
}
| 10,458 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
RenameResourceDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/RenameResourceDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import static org.junit.Assert.assertTrue;
import java.text.MessageFormat;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotLabel;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
/**
* 重命名资源对话框
* @author felix_lu
* @version
* @since JDK1.6
*/
public class RenameResourceDialog extends SWTBotShell {
private SWTBot dialogBot = this.bot();
private String newName;
private String oldName;
/**
* 按钮标题查找对话框
*/
public RenameResourceDialog() {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitleRenameResource")).widget);
}
/**
* @param oldName
* 旧文件名，仅用于判断是否出现 out of sync 的提示
*/
public RenameResourceDialog(String oldName) {
this();
this.oldName = oldName;
}
/**
* @param oldName
* 旧文件名，仅用于判断是否出现 out of sync 的提示
* @param newName
* 新文件名，仅用于输入
*/
public RenameResourceDialog(String oldName, String newName) {
this(oldName);
this.newName = newName;
}
/************************************
* 常用方法
************************************/
/**
* 在文本框中填写新名称
*/
public void setNewName() {
assertTrue("参数错误：未设置 newName。", newName != null);
txtWLblNewName().isActive();
txtWLblNewName().setText(newName);
}
/**
* @param newName
* 需要在文本框中填写的新名称
*/
public void setNewName(String newName) {
this.newName = newName;
setNewName();
}
/**
* @return 是表示出现 out of sync 提示
*/
public boolean isOutOfSync() {
assertTrue("参数错误：未设置 oldName。", oldName != null);
try {
lblOutOfSync(oldName).isVisible();
return true;
} catch (WidgetNotFoundException e) {
return false;
}
}
/************************************
* 界面映射
************************************/
/**
* @return 按钮：取消;
*/
public SWTBotButton btnCancel() {
return dialogBot.button(TsUIConstants.getString("btnCancel"));
}
/**
* @return 按钮：确定;
*/
public SWTBotButton btnOK() {
return dialogBot.button(TsUIConstants.getString("btnOK"));
}
/**
* @return 按钮：预览 未展开;
*/
public SWTBotButton btnPreviewCollapsed() {
return dialogBot.button(TsUIConstants.getString("btnPreviewCollapsed"));
}
/**
* @return 按钮：预览 展开;
*/
public SWTBotButton btnPreviewExpanded() {
return dialogBot.button(TsUIConstants.getString("btnPreviewExpanded"));
}
/**
* @param oldName
* 旧文件名，在信息中包含
* @return 文字标签：out of sync 信息的内容
*/
public SWTBotLabel lblOutOfSync(String oldName) {
return dialogBot.label(MessageFormat.format(TsUIConstants.getString("lblOutOfSync"), oldName));
}
/**
* @return 文本框：新名称;
*/
public SWTBotText txtWLblNewName() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblNewName"));
}
}
| 3,409 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
CreateDatabaseDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/CreateDatabaseDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
/**
* 创建库对话框
* @author felix_lu
*/
public class CreateDatabaseDialog extends SWTBotShell {
private SWTBot dialogBot = this.bot();
/**
* 按标题识别对话框
*/
public CreateDatabaseDialog() {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitleCreateDatabase")).widget);
}
/**
* @return 文本框：数据库名称;
*/
public SWTBotText txtWLblDatabaseName() {
// return dialogBot.text();
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblDatabaseName"));
}
/**
* @return 文本框：数据库名称非法信息;
*/
public SWTBotText msgDBNameInvalid() {
return dialogBot.text(TsUIConstants.getString("msgDBNameInvalid"));
}
/**
* @return 文本框：数据库名称过长信息;
*/
public SWTBotText msgDBNameTooLong() {
return dialogBot.text(TsUIConstants.getString("msgDBNameTooLong"));
}
/**
* @return 文本框：数据库名称已存在信息;
*/
public SWTBotText msgDBExists() {
return dialogBot.text(TsUIConstants.getString("msgDBExists"));
}
/**
* @return 按钮：确定;
*/
public SWTBotButton btnOK() {
return dialogBot.button(TsUIConstants.getString("btnOK"));
}
/**
* @return 按钮：取消;
*/
public SWTBotButton btnCancel() {
return dialogBot.button(TsUIConstants.getString("btnCancel"));
}
}
| 1,698 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ProjectSettingDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/ProjectSettingDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.widgets.HsSWTBotTable;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotCombo;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotList;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 项目设置对话框
* @author felix_lu
* @version
* @since JDK1.6
*/
public class ProjectSettingDialog extends SWTBotShell {
private SWTBot dlgBot = this.bot();
/**
* 按标题查找对话框
*/
public ProjectSettingDialog() {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitleProjectSetting")).widget);
}
/**
* @return 树节点：项目信息;
*/
public SWTBotTreeItem treiProjectInfo() {
return dlgBot.tree().expandNode(TsUIConstants.getString("treiProjectInfo"));
}
/**
* @return 文本框：客户;
*/
public SWTBotText txtWLblClient() {
return dlgBot.textWithLabel(TsUIConstants.getString("txtWLblClient_"));
}
/**
* @return 文本框：公司;
*/
public SWTBotText txtWLblCompany() {
return dlgBot.textWithLabel(TsUIConstants.getString("txtWLblCompany"));
}
/**
* @return 文本框：邮箱;
*/
public SWTBotText txtWLblEMail() {
return dlgBot.textWithLabel(TsUIConstants.getString("txtWLblEMail"));
}
/**
* @return 文本框：备注;
*/
public SWTBotText txtWLblRemark() {
return dlgBot.textWithLabel(TsUIConstants.getString("txtWLblRemark"));
}
/**
* @return 树节点：项目语言;
*/
public SWTBotTreeItem treiProjectLanguage() {
return treiProjectInfo().expandNode(TsUIConstants.getString("treiProjectLanguage"));
}
/**
* @return 下拉列表：源语言;
*/
public SWTBotCombo cmbSrcLang() {
return dlgBot.comboBox();
}
/**
* @return 列表：可选目标语言;
*/
public SWTBotList lstTgtLangAvailable() {
return dlgBot.list();
}
/**
* @return 列表：已选目标语言;
*/
public SWTBotList lstTgtLangSelected() {
return dlgBot.list(1);
}
/**
* @return 按钮：添加;
*/
public SWTBotButton btnAddToRight() {
return dlgBot.button(TsUIConstants.getString("btnAddToRight"));
}
/**
* @return 按钮：删除;
*/
public SWTBotButton btnDeleteToLeft() {
return dlgBot.button(TsUIConstants.getString("btnDeleteToLeft"));
}
/**
* @return 按钮：删除所有;
*/
public SWTBotButton btnDeleteAll() {
return dlgBot.button(TsUIConstants.getString("btnDeleteAll"));
}
/**
* @return 树节点：记忆库设置;
*/
public SWTBotTreeItem treiTmSetting() {
return treiProjectInfo().expandNode(TsUIConstants.getString("treiTmSetting"));
}
/**
* @return 按钮：导入 TMX;
*/
public SWTBotButton btnImportTMX() {
return dlgBot.button(TsUIConstants.getString("btnImportTMX"));
}
/**
* @return 树节点：术语库设置;
*/
public SWTBotTreeItem treiTbSetting() {
return treiProjectInfo().expandNode(TsUIConstants.getString("treiTbSetting"));
}
/**
* @return 按钮：导入 TBX;
*/
public SWTBotButton btnImportTBX() {
return dlgBot.button(TsUIConstants.getString("btnImportTBX"));
}
/**
* @return 表格：记忆库/术语库列表;
*/
public HsSWTBotTable table() {
return new HsSWTBotTable(dlgBot.table());
}
/**
* @return 文本 列名：名称;
*/
public String tblColName() {
return TsUIConstants.getString("tblColName");
}
/**
* @return 文本 列名：类型;
*/
public String tblColType() {
return TsUIConstants.getString("tblColType");
}
/**
* @return 文本 列名：服务器地址;
*/
public String tblColAddress() {
return TsUIConstants.getString("tblColAddress");
}
/**
* @return 文本 列名：是否匹配;
*/
public String tblColMatch() {
return TsUIConstants.getString("tblColMatch");
}
/**
* @return 文本 列名：默认库;
*/
public String tblColDefaultDB() {
return TsUIConstants.getString("tblColDefaultDB");
}
/**
* @return 按钮：添加;
*/
public SWTBotButton btnAdd() {
return dlgBot.button(TsUIConstants.getString("btnAddA"));
}
/**
* @return 按钮：创建;
*/
public SWTBotButton btnCreate() {
return dlgBot.button(TsUIConstants.getString("btnCreate"));
}
/**
* @return 按钮：删除;
*/
public SWTBotButton btnDelete() {
return dlgBot.button(TsUIConstants.getString("btnDeleteD"));
}
/**
* @return 按钮：取消;
*/
public SWTBotButton btnCancel() {
return dlgBot.button(TsUIConstants.getString("btnCancel"));
}
/**
* @return 按钮：确定;
*/
public SWTBotButton btnOK() {
return dlgBot.button(TsUIConstants.getString("btnOK"));
}
}
| 4,900 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
PreferencesDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/PreferencesDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.finders.HsSWTBot;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.widgets.HsSWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotCheckBox;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotRadio;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotSpinner;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 首选项对话框
* @author felix_lu
*/
public class PreferencesDialog extends HsSWTBotShell {
private HsSWTBot dlgBot = this.bot();
private SWTBotTree tree = dlgBot.tree();
/**
* 按标题识别对话框
*/
public PreferencesDialog() {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitlePreferences")).widget);
}
/* 记忆库相关设置 */
/**
* @return 树节点：记忆库;
*/
public SWTBotTreeItem treiTMDB() {
return tree.expandNode(TsUIConstants.getString("treiTMDB"));
}
/**
* @return 复选框：启用共享库提示;
*/
public SWTBotCheckBox tmChkbxShareDBTips() {
return dlgBot.checkBox(TsUIConstants.getString("prefTMChkbxShareDBTips"));
}
/**
* @return 复选框：使用自动快速翻译;
*/
public SWTBotCheckBox tmChkbxAutoQT() {
return dlgBot.checkBox(TsUIConstants.getString("prefTMChkbxAutoQT"));
}
/**
* @return 复选框：匹配存在时不应用记忆库;
*/
public SWTBotCheckBox tmChkbxMatchExistNotApplyTM() {
return dlgBot.checkBox(TsUIConstants.getString("prefTMChkbxMatchExistNotApplyTM"));
}
/**
* @return 复选框：搜索记忆库时区分大小写;
*/
public SWTBotCheckBox tmChkbxMatchCase() {
return dlgBot.checkBox(TsUIConstants.getString("prefTMChkbxMatchCase"));
}
/**
* @return 复选框：匹配时使用标记自动补全;
*/
public SWTBotCheckBox tmChkbxAutoCompleteTag() {
return dlgBot.checkBox(TsUIConstants.getString("prefTMChkbxAutoCompleteTag"));
}
/**
* @return 复选框：匹配时是否忽略标记;
*/
public SWTBotCheckBox tmChkbxIgnoreTag() {
return dlgBot.checkBox(TsUIConstants.getString("prefTMChkbxIgnoreTag"));
}
/**
* @return 带上下箭头按钮的数字文本框：上下文匹配文本段数量;
*/
public SWTBotSpinner tmSpinContextNumber() {
return dlgBot.spinner(TsUIConstants.getString("prefTMSpinContextNumber"));
}
/**
* @return 带上下箭头按钮的数字文本框：记忆库最大匹配数;
*/
public SWTBotSpinner tmSpinMatchNumber() {
return dlgBot.spinner(TsUIConstants.getString("prefTMSpinMatchNumber"));
}
/**
* @return 带上下箭头按钮的数字文本框：记忆库最低匹配率;
*/
public SWTBotSpinner tmSpinMinMatchPercentage() {
return dlgBot.spinner(TsUIConstants.getString("prefTMSpinMinMatchPercentage"));
}
/**
* @return 单选按钮：匹配率相同时排序策略，默认库优先;
*/
public SWTBotRadio tmRadBtnSortDefaultDBFirst() {
return dlgBot.radio(TsUIConstants.getString("prefTMRadBtnSortDefaultDBFirst"));
}
/**
* @return 单选按钮：匹配率相同时排序策略，更新时间倒序排列;
*/
public SWTBotRadio tmRadBtnSortUpdateTimeReverse() {
return dlgBot.radio(TsUIConstants.getString("prefTMRadBtnSortUpdateTimeReverse"));
}
/**
* @return 单选按钮：记忆库更新策略，始终增加;
*/
public SWTBotRadio tmRadBtnUpdateModeAlwaysAdd() {
return dlgBot.radio(TsUIConstants.getString("prefTMRadBtnUpdateModeAlwaysAdd"));
}
/**
* @return 单选按钮：记忆库更新策略，重复覆盖;
*/
public SWTBotRadio tmRadBtnUpdateModeOverwrite() {
return dlgBot.radio(TsUIConstants.getString("prefTMRadBtnUpdateModeOverwrite"));
}
/**
* @return 单选按钮：记忆库更新策略，重复忽略;
*/
public SWTBotRadio tmRadBtnUpdateModeIgnore() {
return dlgBot.radio(TsUIConstants.getString("prefTMRadBtnUpdateModeIgnore"));
}
/* 术语库相关设置 */
/**
* @return 树节点：术语库;
*/
public SWTBotTreeItem treiTBDB() {
return tree.expandNode(TsUIConstants.getString("treiTBDB"));
}
/**
* @return 单选按钮：术语库更新策略，始终增加;
*/
public SWTBotRadio tbRadBtnUpdateModeAlwaysAdd() {
return dlgBot.radio(TsUIConstants.getString("prefTBRadBtnUpdateModeAlwaysAdd"));
}
/**
* @return 单选按钮：术语库更新策略，重复覆盖;
*/
public SWTBotRadio tbRadBtnUpdateModeOverwrite() {
return dlgBot.radio(TsUIConstants.getString("prefTBRadBtnUpdateModeOverwrite"));
}
/**
* @return 单选按钮：术语库更新策略，重复合并;
*/
public SWTBotRadio tbRadBtnUpdateModeMerge() {
return dlgBot.radio(TsUIConstants.getString("prefTBRadBtnUpdateModeMerge"));
}
/**
* @return 单选按钮：术语库更新策略，重复忽略;
*/
public SWTBotRadio tbRadBtnUpdateModeIgnore() {
return dlgBot.radio(TsUIConstants.getString("prefTBRadBtnUpdateModeIgnore"));
}
/* 预翻译 */
/**
* @return 树节点：预翻译;
*/
public SWTBotTreeItem treiPreTranslation() {
return tree.expandNode(TsUIConstants.getString("treiPreTranslation"));
}
/**
* @return 复选框：预翻译区分大小写;
*/
public SWTBotCheckBox transPreChkbxCaseSensitive() {
return dlgBot.checkBox(TsUIConstants.getString("prefTransPreChkbxCaseSensitive"));
}
/**
* @return Spinner：预翻译最低匹配率;
*/
public SWTBotSpinner transPreSpinMinMatchPercentage() {
return dlgBot.spinner(TsUIConstants.getString("prefTransPreSpinMinMatchPercentage"));
}
/**
* @return 单选按钮：保留现有匹配;
*/
public SWTBotRadio transPreRadBtnOverwriteModeKeepCurrent() {
return dlgBot.radio(TsUIConstants.getString("prefTransPreRadBtnOverwriteModeKeepCurrent"));
}
/**
* @return 单选按钮：如果匹配率比当前高，覆盖现有匹配;
*/
public SWTBotRadio transPreRadBtnOverwriteModeOverwriteIfHigher() {
return dlgBot.radio(TsUIConstants.getString("prefTransPreRadBtnOverwriteModeOverwriteIfHigher"));
}
/**
* @return 单选按钮：始终覆盖现有匹配;
*/
public SWTBotRadio transPreRadBtnOverwriteModeAlwaysOverwrite() {
return dlgBot.radio(TsUIConstants.getString("prefTransPreRadBtnOverwriteModeAlwaysOverwrite"));
}
/* 通用按钮 */
/**
* @return 按钮：恢复默认设置;
*/
public SWTBotButton btnRestoreDefaults() {
return dlgBot.button(TsUIConstants.getString("btnRestoreDefaults"));
}
/**
* @return 按钮：应用设置;
*/
public SWTBotButton btnApply() {
return dlgBot.button(TsUIConstants.getString("btnApply"));
}
/**
* @return 按钮：确定;
*/
public SWTBotButton btnOK() {
return dlgBot.button(TsUIConstants.getString("btnOK"));
}
/**
* @return 按钮：取消;
*/
public SWTBotButton btnCancel() {
return dlgBot.button(TsUIConstants.getString("btnCancel"));
}
}
| 6,994 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
RenameProblemsDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/RenameProblemsDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import static org.junit.Assert.assertTrue;
import java.text.MessageFormat;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotLabel;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
/**
* 重命名问题对话框
* @author felix_lu
* @version
* @since JDK1.6
*/
public class RenameProblemsDialog extends SWTBotShell {
private SWTBot dialogBot = this.bot();
private String name;
private String invalidChar;
/**
* 按钮标题查找对话框
*/
public RenameProblemsDialog() {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitleRenameProblems")).widget);
}
/**
* @param name
* 文件名，用于判断是否出现 out of sync 或名称非法的提示
* @param invalidChar
* 若为名称非法的情况，需要指出其中的非法字符
*/
public RenameProblemsDialog(String name, String invalidChar) {
this();
this.name = name;
if (invalidChar != null) {
this.invalidChar = invalidChar;
}
}
/************************************
* 常用方法
************************************/
/**
* @return 是表示出现 out of sync 提示
*/
public boolean isOutOfSync() {
assertTrue("参数错误：未设置 name。", name != null);
try {
lblOutOfSync(name).isVisible();
return true;
} catch (WidgetNotFoundException e) {
return false;
}
}
/**
* @return 是表示出现名称非法提示;
*/
public boolean isInvalidMsgVisible() {
assertTrue("参数错误：未设置 name 或 invalidChar。", (name != null && invalidChar != null));
try {
lblInvalidChar(name, invalidChar).isVisible();
return true;
} catch (WidgetNotFoundException e) {
return false;
}
}
/************************************
* 界面映射
************************************/
/**
* @return 按钮：确定;
*/
public SWTBotButton btnOK() {
return dialogBot.button(TsUIConstants.getString("btnOK"));
}
/**
* @return 按钮：详情 未展开;
*/
public SWTBotButton btnDetailsCollapsed() {
return dialogBot.button(TsUIConstants.getString("btnDetailsCollapsed"));
}
/**
* @return 按钮：详情 展开;
*/
public SWTBotButton btnDetailsExpanded() {
return dialogBot.button(TsUIConstants.getString("btnDetailsExpanded"));
}
/**
* @param name
* 文件名，在信息中包含
* @return 文字标签：out of sync 信息的内容
*/
public SWTBotLabel lblOutOfSync(String name) { // FIXME: 新的 Out Of Sync 信息控件可能不是 Label 了。
return dialogBot.label(MessageFormat.format(TsUIConstants.getString("lblOutOfSync"), name));
}
/**
* @param name
* 含非法字符的项目名
* @param invalidChar
* 名称中的非法字符
* @return 文字标签：项目名称非法的信息内容;
*/
public SWTBotLabel lblInvalidChar(String name, String invalidChar) {
return dialogBot.label(MessageFormat.format(TsUIConstants.getString("lblInvalidChar"), invalidChar, name));
}
}
| 3,316 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
InputDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/InputDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
/**
* 输入对话框
* @author felix_lu
*/
public class InputDialog extends SWTBotShell {
public static final String OPEN_FILE = "dlgTitleOpenFile";
private SWTBot dialogBot = this.bot();
/**
* 按标题识别对话框
* @param dlgTitle
* 对话框标题，请使用本类提供的常量
*/
public InputDialog(String dlgTitle) {
super(HSBot.bot().shell(TsUIConstants.getString(dlgTitle)).widget);
}
/**
* @return 文本框（这种对话框通常只有一个文本框）;
*/
public SWTBotText txt() {
return dialogBot.text();
}
/**
* @return 按钮：确定;
*/
public SWTBotButton btnOK() {
return dialogBot.button(TsUIConstants.getString("btnOK"));
}
/**
* @return 按钮：取消;
*/
public SWTBotButton btnCancel() {
return dialogBot.button(TsUIConstants.getString("btnCancel"));
}
}
| 1,227 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ProjectExistsDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/ProjectExistsDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import static org.junit.Assert.assertTrue;
import java.text.MessageFormat;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotLabel;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
/**
* 项目已存在，是否要覆盖对话框
* @author felix_lu
* @version
* @since JDK1.6
*/
public class ProjectExistsDialog extends SWTBotShell {
private SWTBot dialogBot = this.bot();
private String name;
/**
* 按钮标题查找对话框
*/
public ProjectExistsDialog() {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitleProjectExists")).widget);
}
/**
* @param name
* 文件名，用于判断是否项目重名的提示
*/
public ProjectExistsDialog(String name) {
this();
this.name = name;
}
/************************************
* 常用方法
************************************/
/**
* @return 是表示出现项目已存在提示;
*/
public boolean isProjectExistsMsgVisible() {
assertTrue("参数错误：未设置 name。", name != null);
try {
lblProjectExists(name).isVisible();
return true;
} catch (WidgetNotFoundException e) {
return false;
}
}
/************************************
* 界面映射
************************************/
/**
* @return 按钮：覆盖;
*/
public SWTBotButton btnYes() {
return dialogBot.button(TsUIConstants.getString("btnYes"));
}
/**
* @return 按钮：不覆盖;
*/
public SWTBotButton btnNo() {
return dialogBot.button(TsUIConstants.getString("btnNo"));
}
/**
* @param name 项目名称
* @return 文字标签：项目已存在的提示、并询问是否需要覆盖信息;
*/
public SWTBotLabel lblProjectExists(String name) {
return dialogBot.label(MessageFormat.format(TsUIConstants.getString("lblProjectExists"), name, name));
}
}
| 2,138 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
CreateMemoryDbDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/CreateMemoryDbDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
/**
* 创建库对话框
* @author roy_xiao
*/
public class CreateMemoryDbDialog extends SWTBotShell {
private SWTBot dialogBot = this.bot();
/**
* 按标题识别对话框
*/
public CreateMemoryDbDialog(String title) {
super(HSBot.bot().shell(TsUIConstants.getString(title)).widget);
}
/**
* @return 文本框：数据库名称;
*/
public SWTBotText txtWLblDatabaseName() {
// return dialogBot.text();
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblDatabaseName"));
}
/**
* @return 文本框：数据库名称非法信息;
*/
public SWTBotText msgDBNameInvalid() {
return dialogBot.text(TsUIConstants.getString("msgDBNameInvalid"));
}
/**
* @return 文本框：数据库名称过长信息;
*/
public SWTBotText msgDBNameTooLong() {
return dialogBot.text(TsUIConstants.getString("msgDBNameTooLong"));
}
/**
* @return 文本框：数据库名称已存在信息;
*/
public SWTBotText msgDBExists() {
return dialogBot.text(TsUIConstants.getString("msgDBExists"));
}
/**
* @return 按钮：确定;
*/
public SWTBotButton btnOK() {
return dialogBot.button(TsUIConstants.getString("btnOK"));
}
/**
* @return 按钮：取消;
*/
public SWTBotButton btnCancel() {
return dialogBot.button(TsUIConstants.getString("btnCancel"));
}
}
| 1,691 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ManageCustomFilterDialog.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.ui/src/net/heartsome/cat/ts/test/ui/dialogs/ManageCustomFilterDialog.java | package net.heartsome.cat.ts.test.ui.dialogs;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotList;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotRadio;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
/**
* 管理自定义过滤器条件对话框
* @author felix_lu
*/
public class ManageCustomFilterDialog extends SWTBotShell {
private SWTBot dialogBot = this.bot();
/**
* 按标题识别对话框
*/
public ManageCustomFilterDialog() {
super(HSBot.bot().shell(TsUIConstants.getString("dlgTitleManageCustomFilter")).widget);
}
/**
* @return 按钮：添加自定义过滤规则;
*/
public SWTBotButton btnAdd() {
return dialogBot.button(TsUIConstants.getString("btnAdd"));
}
/**
* @return 按钮：添加条件;
*/
public SWTBotButton btnAddCondition() {
return dialogBot.button(TsUIConstants.getString("btnAddCondition"));
}
/**
* @param index 指定按钮索引
* @return 按钮：添加条件;
*/
public SWTBotButton btnAddCondition(int index) {
return dialogBot.button(TsUIConstants.getString("btnAddCondition"), index);
}
/**
* @return 按钮：关闭;
*/
public SWTBotButton btnClose() {
return dialogBot.button(TsUIConstants.getString("btnClose"));
}
/**
* @return 按钮：删除自定义过滤规则;
*/
public SWTBotButton btnDelete() {
return dialogBot.button(TsUIConstants.getString("btnDelete"));
}
/**
* @param index 指定按钮索引
* @return 按钮：删除条件;
*/
public SWTBotButton btnDeleteCondition(int index) {
return dialogBot.button(TsUIConstants.getString("btnDeleteCondition"), index);
}
/**
* @return 按钮：编辑规则;
*/
public SWTBotButton btnEdit() {
return dialogBot.button(TsUIConstants.getString("btnEdit"));
}
/**
* @return 按钮：保存;
*/
public SWTBotButton btnSave() {
return dialogBot.button(TsUIConstants.getString("btnSave"));
}
/**
* @return 列表：自定义过滤规则;
*/
public SWTBotList lstWLblCustomFilter() {
return dialogBot.listWithLabel(TsUIConstants.getString("lstWLblCustomFilter"));
}
/**
* @return 单选按钮：匹配所有条件;
*/
public SWTBotRadio radBtnMatchAllConditions() {
return dialogBot.radio(TsUIConstants.getString("radBtnMatchAllConditions"));
}
/**
* @return 单选按钮：匹配任一条件;
*/
public SWTBotRadio radBtnMatchAnyCondition() {
return dialogBot.radio(TsUIConstants.getString("radBtnMatchAnyCondition"));
}
/**
* @return 文本框：规则名称;
*/
public SWTBotText txtWLblFilterName() {
return dialogBot.textWithLabel(TsUIConstants.getString("txtWLblFilterName"));
}
}
| 2,907 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
PreTranslate.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.basecase/src/net/heartsome/cat/ts/test/basecase/menu/translation/PreTranslate.java | package net.heartsome.cat.ts.test.basecase.menu.translation;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.basecase.common.ExcelData;
import net.heartsome.cat.ts.test.basecase.menu.file.ProjectFile;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.Entry;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.ExpectedResult;
import net.heartsome.cat.ts.test.ui.dialogs.PreTranslateDialog;
import net.heartsome.cat.ts.test.ui.dialogs.PreTranslateResultDialog;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException;
import org.eclipse.swtbot.swt.finder.keyboard.Keystrokes;
import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
/**
* 预翻译基础用例，封装测试该功能常用的方法，预翻译用到的文件、数据库等，需要在此类之外复制或设置好。
* @author felix_lu
* @version
* @since JDK1.6
*/
public class PreTranslate {
private TS ts;
private PreTranslateDialog dlgPreTrans;
private PreTranslateResultDialog dlgPreTransResult;
private HsRow row;
private ExcelData data;
private ProjectFile prjFile;
private String prjName;
private String fileType;
private String filePath;
private String fileName;
private String fileFullPath;
private int dbType;
private String server;
private String port;
private String instance;
private String dbPath;
private String username;
private String password;
private String dbName;
private ExpectedResult expResult;
/**
* @param row
* 用于读取测试数据的 Excel 行对象
*/
public PreTranslate(HsRow row) {
this.row = row;
data = new ExcelData(row);
ts = TS.getInstance();
}
/**
* 选择文件;
*/
private void select() {
prjFile = new ProjectFile(row);
prjFile.select();
fileFullPath = prjFile.getPath();
}
/**
* 打开预翻译对话框
* @param from
* 入口，请使用 TSUIConstants 类提供的常量
* @return 预翻译对话框对象;
*/
private PreTranslateDialog openPreTransDlg(Entry from) {
select();
switch (from) {
case MENU: {
ts.menuTranslationPreTrans().click();
break;
}
case CONTEXT_MENU: {
ProjectTreeView.getInstance().ctxMenuPreTranslate().click();
break;
}
case SHORTCUT: {
ProjectTreeView.getTree().pressShortcut(Keystrokes.SHIFT, Keystrokes.F5);
break;
}
default: {
assertTrue("参数错误，无此入口：" + from, false);
}
}
dlgPreTrans = new PreTranslateDialog();
assertTrue("预翻译对话框未正确打开。", dlgPreTrans.isOpen());
return dlgPreTrans;
}
/**
* 预翻译
* @param from
* 入口，请使用 TSUIConstants 类提供的常量;
*/
public void preTranslate(Entry from) {
getDataPreTrans();
select();
openPreTransDlg(from);
assertTrue("未正确添加选中的文件：" + fileFullPath,
dlgPreTrans.table().containsTextInColumn(fileFullPath, dlgPreTrans.tblColFile()));
dlgPreTrans.btnOK().click();
HSBot.bot().waitUntil(new DefaultCondition() {
public boolean test() throws Exception {
try {
dlgPreTransResult = new PreTranslateResultDialog();
return dlgPreTransResult.isOpen();
} catch (WidgetNotFoundException e) {
return false;
}
}
public String getFailureMessage() {
return "未正确显示预翻译结果对话框。";
}
}, 3600000);
assertTrue("未正确该文件的预翻译结果：" + fileFullPath,
dlgPreTransResult.table().containsTextInColumn(fileFullPath, dlgPreTransResult.tblColFile()));
dlgPreTransResult.btnOK().click();
}
/**
* 从 Excel 文件中读取测试数据;
*/
private void getDataPreTrans() {
assertTrue("参数错误，row 为 null。", row != null);
prjName = data.getTextOrEmpty(ExcelData.colPrjName);
fileType = data.getTextOrEmpty(ExcelData.colFileType);
filePath = data.getTextOrEmpty(ExcelData.colFilePath);
fileName = data.getTextOrEmpty(ExcelData.colFileName);
expResult = data.getExpectedResult();
// dbType = data.getDBType();
// server = data.getServer();
// port = data.getPort();
// instance = data.getInstance();
// dbPath = data.getDBPath();
// dbName = data.getDBName();
// username = data.getUsername();
// password = data.getPassword();
}
}
| 4,540 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ImportToDB.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.basecase/src/net/heartsome/cat/ts/test/basecase/menu/db/ImportToDB.java | package net.heartsome.cat.ts.test.basecase.menu.db;
import static org.junit.Assert.assertTrue;
import java.io.File;
import net.heartsome.cat.ts.test.basecase.common.ExcelData;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.Entry;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.ExpectedResult;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.ImportType;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.UpdateMode;
import net.heartsome.cat.ts.test.ui.dialogs.ImportDialog;
import net.heartsome.cat.ts.test.ui.dialogs.InputDialog;
import net.heartsome.cat.ts.test.ui.dialogs.PreferencesDialog;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.tasks.Waits;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.waits.IsWidgetInvisible;
import net.heartsome.test.swtbot.waits.IsWidgetTextEquals;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException;
/**
* 导入 TMX、TBX 的基础用例封装。
* @author felix_lu
* @version
* @since JDK1.6
*/
public class ImportToDB {
private TS ts;
private HsRow row;
private ExcelData data;
private ImportDialog dialog;
private ImportType importType;
private String filePath;
private String dbName;
private UpdateMode updateMode;
private ExpectedResult expectedResult;
/**
* @param row
* Excel 数据来源
*/
public ImportToDB(ImportType importType, HsRow row) {
this.row = row;
data = new ExcelData(row);
this.importType = importType;
ts = TS.getInstance();
}
/**
* 完整流程：导入 ImportType.TMX 文件
* @param from
* 功能入口，请使用 TSUIConstants 类提供的枚举;
*/
public void importTMX(Entry from) {
assertTrue("仅功能仅在导入模式为 ImportType.TMX 时可用。", importType.equals(TsUIConstants.ImportType.TMX));
importFile(from);
}
/**
* 完整流程：导入 ImportType.TBX 文件
* @param from
* 功能入口，请使用 TSUIConstants 类提供的枚举;
*/
public void importTBX(Entry from) {
assertTrue("仅功能仅在导入模式为 ImportType.TBX 时可用。", importType.equals(TsUIConstants.ImportType.TBX));
importFile(from);
}
/**
* @param from
* 功能入口，请使用 TSUIConstants 类提供的枚举;
*/
private void importFile(Entry from) {
getDataAll();
openImportDialog(from);
// 预期结果验证：未选择文件
if (expectedResult.equals(TsUIConstants.ExpectedResult.NO_FILE)) {
assertTrue(dialog.txtWLblFile().getText().equals(""));
dialog.btnFinish().click();
assertTrue(dialog.msgNoFileToImport().isVisible());
} else {
// 无效路径（文件不存在）的预处理
if (expectedResult.equals(TsUIConstants.ExpectedResult.INVALID_PATH)) {
File file = new File(filePath);
if (file.exists()) { // 此预期结果分支不应该存在该文件，故需先删除
file.delete();
}
}
// 浏览文件
dialog.btnBrowse().click();
// 用 Mock 的输入对话框代替系统原生对话框来输入文件路径
InputDialog idlg = new InputDialog(InputDialog.OPEN_FILE);
idlg.txt().setText(filePath);
idlg.btnOK().click();
Waits.shellClosed(idlg);
HSBot.bot().waitUntil(new IsWidgetTextEquals(dialog.txtWLblFile(), filePath), 10000);
// 预期结果验证：未选择数据库
if (expectedResult.equals(TsUIConstants.ExpectedResult.NO_DB)) {
assertTrue(dialog.txtWLblDatabase().getText().equals(""));
assertTrue(!dialog.btnFinish().isEnabled());
assertTrue(dialog.msgNoDBToImport().isVisible());
} else {
// 选择库
dialog.btnSelectDB().click();
MemoryDBManagement md = new MemoryDBManagement(row);
md.setFromImportDb(true);
md.selectDB(dbName);
// new DBManagement(row).selectDB(dbName);
assertTrue("记忆库/术语库未正确选择。", dbName.equals(dialog.txtWLblDatabase().getText()));
// 选择更新策略
dialog.btnSetting().click();
PreferencesDialog dlgPref = new PreferencesDialog();
selectUpdateMode(dlgPref);
// 开始导入
dialog.btnFinish().click();
// 预期结果验证：成功导入文件
if (expectedResult.equals(TsUIConstants.ExpectedResult.SUCCESS)) {
try {
HSBot.bot().waitUntil(new IsWidgetInvisible(dialog.msgImporting()), 600000); // 暂时只设置等待 10 分钟
} catch (WidgetNotFoundException e) {
e.printStackTrace();
}
assertTrue(dialog.msgImportSuccess().isVisible());
// 预期结果验证：文件内容有误、无效路径（文件不存在）、错误的文件类型
} else if (expectedResult.equals(TsUIConstants.ExpectedResult.FILE_ERROR)
|| expectedResult.equals(TsUIConstants.ExpectedResult.INVALID_PATH)
|| expectedResult.equals(TsUIConstants.ExpectedResult.WRONG_TYPE)) {
assertTrue(dialog.msgFileError().isVisible());
} else {
assertTrue("无此预期结果：" + expectedResult, false);
}
}
}
if (dialog.isOpen()) {
dialog.btnCancel().click();
Waits.shellClosed(dialog);
}
}
/**
* @param from
* 功能入口，请使用 TSUIConstants 类提供的枚举;
* @return 导入对话框对象
*/
public ImportDialog openImportDialog(Entry from) {
switch (from) {
case MENU: {
switch (importType) {
case TMX: {
ts.menuDBImportTMXFile().click();
dialog = new ImportDialog(ImportDialog.TMX);
break;
}
case TBX: {
ts.menuDBImportTBXFile().click();
dialog = new ImportDialog(ImportDialog.TBX);
break;
}
default: {
assertTrue("参数错误，无此导入类型：" + importType, false);
}
}
break;
}
default: {
assertTrue("参数错误，该功能无此入口：" + from, false);
}
}
return dialog;
}
/**
* 选择记忆库/术语库的更新策略。
* @param dlg
* 首选项对话框;
*/
public void selectUpdateMode(PreferencesDialog dlg) {
String msg = "参数错误，无此更新策略：" + updateMode;
switch (importType) {
case TMX: {
assertTrue(dlg.treiTMDB().isSelected());
switch (updateMode) {
case ALWAYS_ADD: {
dlg.tmRadBtnUpdateModeAlwaysAdd().click();
break;
}
case OVERWRITE: {
dlg.tmRadBtnUpdateModeOverwrite().click();
break;
}
case IGNORE: {
dlg.tmRadBtnUpdateModeIgnore().click();
break;
}
default: {
assertTrue(msg, false);
}
}
break;
}
case TBX: {
assertTrue(dlg.treiTBDB().isSelected());
switch (updateMode) {
case ALWAYS_ADD: {
dlg.tbRadBtnUpdateModeAlwaysAdd().click();
break;
}
case OVERWRITE: {
dlg.tbRadBtnUpdateModeOverwrite().click();
break;
}
case MERGE: {
dlg.tbRadBtnUpdateModeMerge().click();
break;
}
case IGNORE: {
dlg.tbRadBtnUpdateModeIgnore().click();
break;
}
default: {
assertTrue(msg, false);
}
}
break;
}
default: {
assertTrue("参数错误，无此导入类型：" + importType, false);
}
}
dlg.btnOK().click();
Waits.shellClosed(dlg);
}
/**
* 从 Excel 文件中读取所需的测试数据，其中库管理部分直接传 HsRow 对象即可，无需在此读取;
*/
public void getDataAll() {
filePath = data.getTextOrEmpty(ExcelData.colFilePath);
dbName = data.getTextOrEmpty(ExcelData.colDBName);
updateMode = data.getUpdateMode();
expectedResult = data.getExpectedResult();
}
}
| 7,599 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
DBManagement.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.basecase/src/net/heartsome/cat/ts/test/basecase/menu/db/DBManagement.java | package net.heartsome.cat.ts.test.basecase.menu.db;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.basecase.common.ExcelData;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.DB;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.Entry;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.ExpectedResult;
import net.heartsome.cat.ts.test.ui.dialogs.CreateDatabaseDialog;
import net.heartsome.cat.ts.test.ui.dialogs.DatabaseManagementDialog;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.msgdialogs.ConfirmDialog;
import net.heartsome.cat.ts.test.ui.msgdialogs.InformationDialog;
import net.heartsome.cat.ts.test.ui.tasks.Waits;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.utils.SWTBotUtils;
import net.heartsome.test.swtbot.widgets.HsSWTBotTable;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import org.eclipse.jface.bindings.keys.KeyStroke;
import org.eclipse.jface.bindings.keys.ParseException;
import org.eclipse.swtbot.swt.finder.keyboard.Keystrokes;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 数据库的相关操作
* @author felix_lu
* @version
* @since JDK1.6
*/
/**
* @author felix_lu
* @version
* @since JDK1.6
*/
public class DBManagement {
private final TS ts = TS.getInstance();
private DatabaseManagementDialog dialog;
private DB dbType;
private String server;
private String port;
private String instance;
private String path;
private String username;
private String password;
private boolean saveConn = true;
private String dbName;
private HsRow rowDBData;
private ExcelData data;
private String connectionName;
private ExpectedResult expectedConnect = null;
private ExpectedResult expectedCreate = null;
// private boolean confirm = false;
private HsSWTBotTable table;
private int mode;
/**
* @param row
* 需要读取数据的 Excel 行。
*/
public DBManagement(HsRow row) {
rowDBData = row;
data = new ExcelData(row);
}
/**
* 完整流程：根据从 Excel 中读取的数据去连接数据库服务器;
* @param from
* 功能入口，请使用 TSUIConstants 类的枚举;
*/
public void connectServer(Entry from) {
mode = DatabaseManagementDialog.MANAGEMENT;
openDBMgmgDialog(from);
getDataConnect(mode);
getDBListFromServer(false);
dialog.btnClose().click();
// TODO 可增加对数据库数据的相关验证
}
/**
* 完整步骤：根据从 Excel 中读取的数据删除已保存的连接信息
* @param from
* 功能入口，请使用 TSUIConstants 类的枚举;
*/
public void deleteConnection(Entry from) {
mode = DatabaseManagementDialog.MANAGEMENT;
openDBMgmgDialog(from);
getDataConnect(mode);
assertTrue("未在已保存的连接信息中找到该连接：" + connectionName, isConnectionSaved());
selectDBType().expandNode(connectionName).select().contextMenu(TsUIConstants.getString("ctxMenuDelete"))
.click();
assertTrue("仍可在已保存的连接信息中找到该连接：" + connectionName, !isConnectionSaved());
dialog.btnClose().click();
}
/**
* 完整流程：根据从 Excel 中读取的数据创建数据库;
* @param from
* 功能入口，请使用 TSUIConstants 类的枚举;
*/
public void createDB(Entry from) {
mode = DatabaseManagementDialog.MANAGEMENT;
openDBMgmgDialog(from);
getDataCreateDB();
getDBListFromServer(true);
if (expectedCreate.equals(TsUIConstants.ExpectedResult.SUCCESS) && isExist(dbName)) { // 若预期结果为创建成功、而该数据库目前已存在，则先删除
table.unselect();
table.select(table.rowIndexOfColumn(dbName, TsUIConstants.getString("tblColDatabaseName")));
dialog.btnDelete().click();
ConfirmDialog dlgConfirm = new ConfirmDialog(ConfirmDialog.dlgTitleTips,
ConfirmDialog.msgDeleteDatabaseFromServer);
dlgConfirm.btnOK().click();
Waits.shellClosed(dlgConfirm);
}
inputDBName();
if (expectedCreate.equals(TsUIConstants.ExpectedResult.SUCCESS)) {
assertTrue("列表中没有该数据库：" + dbName, isExist(dbName));
}
dialog.btnClose().click();
}
/**
* 完整流程：根据从 Excel 中读取的数据删除数据库;
* @param from
* 功能入口，请使用 TSUIConstants 类的枚举;
* @param confirm
* 是否确认删除
*/
public void deleteDB(Entry from, boolean confirm) {
mode = DatabaseManagementDialog.MANAGEMENT;
openDBMgmgDialog(from);
getDataDeleteDB();
getDBListFromServer(true);
assertTrue("列表中没有该数据库：" + dbName, isExist(dbName));
table.unselect();
table.select(table.rowIndexOfColumn(dbName, TsUIConstants.getString("tblColDatabaseName")));
dialog.btnDelete().click();
ConfirmDialog dlgConfirm = new ConfirmDialog(ConfirmDialog.dlgTitleTips,
ConfirmDialog.msgDeleteDatabaseFromServer);
if (confirm) {
dlgConfirm.btnOK().click();
Waits.shellClosed(dlgConfirm);
assertTrue("数据库仍在列表中：" + dbName, !isExist(dbName));
} else {
dlgConfirm.btnCancel().click();
Waits.shellClosed(dlgConfirm);
assertTrue("列表中没有该数据库：" + dbName, isExist(dbName));
}
dialog.btnClose().click();
}
/**
* 完整流程：根据从 Excel 中读取的数据删除数据库;
* @param from
* 功能入口，请使用 TSUIConstants 类的枚举;
*/
public void deleteDB(Entry from) {
deleteDB(from, data.getBoolean(ExcelData.colConfirm));
}
/**
* 完整流程：选择库;
* @param dbName
* 要选择的数据库名称，其他信息直接从 Excel 中读取
*/
public void selectDB(String dbName) {
mode = DatabaseManagementDialog.SELECT;
getDataConnect(mode);
dialog = new DatabaseManagementDialog(DatabaseManagementDialog.SELECT);
dialog.activate();
getDBListFromServer(true);
assertTrue("数据库名称：" + dbName + "，实际内容：" + table.cell(0, 1), isExist(dbName));
table.unselect();
table.select(table.rowIndexOfColumn(dbName, TsUIConstants.getString("tblColDatabaseName")));
dialog.btnOK().click();
Waits.shellClosed(dialog);
}
// 以下为非完整步骤
/**
* @param from
* 入口，请使用 TSUIConstants 类中提供的枚举。
* @return 打开的库管理对话框;
*/
public DatabaseManagementDialog openDBMgmgDialog(Entry from) {
if (from.equals(TsUIConstants.Entry.MENU)) {
ts.menuDBManagement().click();
} else if (from.equals(TsUIConstants.Entry.SHORTCUT)) {
try {
ts.pressShortcut(SWTBotUtils.getCtrlOrCmdKey(), Keystrokes.SHIFT, KeyStroke.getInstance("D"));
} catch (ParseException e) {
e.printStackTrace();
assertTrue("快捷键解析错误。", false);
}
} else {
assertTrue("参数错误，该功能无此入口：" + from, false);
}
dialog = new DatabaseManagementDialog(DatabaseManagementDialog.MANAGEMENT);
return dialog;
}
/**
* 在库管理对话框左边的树上选择并展开指定类型的数据库;
* @return 指定数据库类型的树节点;
*/
public SWTBotTreeItem selectDBType() {
return selectDBType(dbType);
}
/**
* 在库管理对话框左边的树上选择并展开指定类型的数据库
* @param dbType
* 数据库类型;
* @return 指定数据库类型的树节点;
*/
public SWTBotTreeItem selectDBType(DB dbType) {
SWTBotTreeItem treei = null;
assertTrue("库管理对话框为 null。", dialog != null);
switch (dbType) {
case INTERNAL: {
treei = dialog.treiDBInternal().expand().select();
verifyInternalDBWidgets();
break;
}
case MYSQL: {
treei = dialog.treiDBMySQL().expand().select();
verifyExternalDBWidgets(dbType);
break;
}
case ORACLE: {
treei = dialog.treiDBOracle().expand().select();
verifyExternalDBWidgets(dbType);
break;
}
case POSTGRESQL: {
treei = dialog.treiDBPostgreSQL().expand().select();
verifyExternalDBWidgets(dbType);
break;
}
case MSSQL: {
treei = dialog.treiDBMSSQL().expand().select();
verifyExternalDBWidgets(dbType);
break;
}
default: {
assertTrue("无此数据库类型" + dbType, false);
}
}
return treei;
}
/**
* 确认选中内置库后，除路径和浏览按钮外，其他输入控件的状态为不可用;
*/
private void verifyInternalDBWidgets() {
assertTrue(dialog.txtWLblPath().isEnabled());
assertTrue(dialog.btnBrowse().isEnabled());
assertTrue(!dialog.txtWLblServer().isEnabled());
assertTrue(!dialog.txtWLblPort().isEnabled());
assertTrue(!dialog.txtWLblInstance().isEnabled());
assertTrue(!dialog.txtWLblUsername().isEnabled());
assertTrue(!dialog.txtWLblPassword().isEnabled());
}
/**
* 确认选中外部库后，各输入控件的状态与内置库相反，及 Oracle 特有的实例
* @param dbType
* 数据库类型;
*/
private void verifyExternalDBWidgets(DB dbType) {
assertTrue(dialog.txtWLblServer().isEnabled());
assertTrue(dialog.txtWLblPort().isEnabled());
assertTrue(dialog.txtWLblUsername().isEnabled());
assertTrue(dialog.txtWLblPassword().isEnabled());
assertTrue(!dialog.txtWLblPath().isEnabled());
assertTrue(!dialog.btnBrowse().isEnabled());
if (dbType.equals(TsUIConstants.DB.ORACLE)) {
assertTrue(dialog.txtWLblInstance().isEnabled());
} else {
assertTrue(!dialog.txtWLblInstance().isEnabled());
}
}
/**
* 往界面中填写服务器连接信息;
*/
public void setConnectionInfo() {
if (dbType.equals(TsUIConstants.DB.INTERNAL)) {
dialog.txtWLblPath().setText(path);
} else {
dialog.txtWLblServer().setText(server);
dialog.txtWLblPort().setText(port);
dialog.txtWLblUsername().setText(username);
dialog.txtWLblPassword().setText(password);
if (dbType.equals(TsUIConstants.DB.ORACLE)) {
dialog.txtWLblInstance().setText(instance);
}
}
if (saveConn) {
dialog.chkbxRemeber().select();
}
}
/**
* 在数据库服务器上查询数据库列表
* @param useSavedConnection
* 是否使用已保存的连接;
* @return
*/
public HsSWTBotTable getDBListFromServer(boolean useSavedConnection) {
assertTrue("库管理对话框为 null。", dialog != null);
dialog.activate();
if (useSavedConnection && isConnectionSaved()) {
selectDBType().expandNode(connectionName).select();
assertTrue("服务器地址未正确赋值。", server.equals(dialog.txtWLblServer().getText()));
assertTrue("服务器端口未正确赋值。", port.equals(dialog.txtWLblPort().getText()));
} else {
selectDBType();
setConnectionInfo();
dialog.btnSearch().click();
}
if (expectedConnect.equals(TsUIConstants.ExpectedResult.SUCCESS)) {
assertTrue(HSBot.bot().activeShell().getText().equals(dialog.getText()));
} else {
assertTrue(HSBot.bot().shells().length == 3);
InformationDialog msgDlg = null;
switch (expectedConnect) {
case SUCCESS: {
break;
}
case NO_SERVER: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleErrorInfo,
InformationDialog.msgServerIsRequired);
break;
}
case NO_PORT: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleErrorInfo, InformationDialog.msgPortIsRequired);
break;
}
case NO_INSTANCE: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleErrorInfo,
InformationDialog.msgInstanceIsRequired);
break;
}
case NO_PATH: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleErrorInfo, InformationDialog.msgPathIsRequired);
break;
}
case NO_USERNAME: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleErrorInfo,
InformationDialog.msgUsernameIsRequired);
break;
}
case CONNECTION_ERROR: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleTips,
InformationDialog.msgServerConnectionError);
break;
}
default: {
assertTrue("参数错误，无此预期结果：" + expectedConnect, false);
}
}
assertTrue(msgDlg.lblMessage().isVisible());
msgDlg.btnOK().click();
Waits.shellClosed(msgDlg);
}
table = dialog.bot().table();
return table;
}
/**
* @return 是否能在该数据库类型下找到名为 指定服务器:端口号 的已保存连接;
*/
public boolean isConnectionSaved() {
SWTBotTreeItem[] items = selectDBType().getItems();
for (SWTBotTreeItem item : items) {
if (item.getText().equals(connectionName)) {
return true;
}
}
return false;
}
/**
* @return 在当前对话框中验证该数据库是否存在;
*/
public boolean isExist(String dbName) {
return table.containsTextInColumn(dbName, TsUIConstants.getString("tblColDatabaseName"));
}
/**
* 未打开库管理对话框时，直接验证数据库是否存在
* @param dbName
* 要验证的数据库名称
* @param closeDlg
* 是否在获取结果后关闭对话框
* @return 若该数据库存在则返回 true，否则为 false;
*/
public boolean isDBExist(String dbName, boolean closeDlg) {
mode = DatabaseManagementDialog.SELECT;
openDBMgmgDialog(TsUIConstants.Entry.MENU);
getDataConnect(mode);
getDBListFromServer(false);
boolean result = table.containsTextInColumn(dbName, dialog.tblColDatabaseName());
if (closeDlg) {
closeDialog();
}
return result;
}
/**
* 输入数据库名称，含项目名称合法性校验;
*/
public void inputDBName() {
assertTrue(dialog.btnCreate().isEnabled());
dialog.btnCreate().click();
CreateDatabaseDialog dlgInputDBName = new CreateDatabaseDialog();
dlgInputDBName.txtWLblDatabaseName().setText(dbName);
dlgInputDBName.btnOK().click();
switch (expectedCreate) {
case INVALID_NAME: {
assertTrue("未正确显示名称非法信息。", dlgInputDBName.msgDBNameInvalid().isVisible());
dlgInputDBName.btnCancel().click();
break;
}
case DUPLICATED_NAME: {
assertTrue("未正确显示重名信息。", dlgInputDBName.msgDBExists().isVisible());
dlgInputDBName.btnCancel().click();
break;
}
case LONG_NAME: {
assertTrue("未正确显示名称过长信息。", dlgInputDBName.msgDBNameTooLong().isVisible());
dlgInputDBName.btnCancel().click();
break;
}
}
Waits.shellClosed(dlgInputDBName);
}
/**
* 关闭库管理对话框;
*/
public void closeDialog() {
dialog.btnClose().click();
}
// 以下为读取 Excel 文件中的测试数据相关方法
/**
* 从 Excel 文件中读取连接数据库服务器相关数据，并赋值给成员变量;
*/
public void getDataConnect(int mode) {
assertTrue("参数错误：Excel 列为 null。", rowDBData != null);
dbType = data.getDBType();
server = data.getTextOrEmpty(ExcelData.colServer);
port = data.getTextOrEmpty(ExcelData.colPort);
instance = data.getTextOrEmpty(ExcelData.colInstance);
path = data.getTextOrEmpty(ExcelData.colDBPath);
username = data.getTextOrEmpty(ExcelData.colUsername);
password = data.getTextOrEmpty(ExcelData.colPassword);
saveConn = data.getBoolean(ExcelData.colSaveConn);
if (mode == DatabaseManagementDialog.MANAGEMENT) {
expectedCreate = data.getExpectedResult();
if (expectedCreate.equals(TsUIConstants.ExpectedResult.INVALID_NAME)
|| expectedCreate.equals(TsUIConstants.ExpectedResult.DUPLICATED_NAME)
|| expectedCreate.equals(TsUIConstants.ExpectedResult.LONG_NAME)) {
expectedConnect = TsUIConstants.ExpectedResult.SUCCESS; // 创建失败，隐含连接成功
} else {
expectedConnect = data.getExpectedResult();
}
} else if (mode == DatabaseManagementDialog.SELECT) {
dbName = data.getTextOrEmpty(ExcelData.colDBName);
// assertTrue(dbName != null); 因选择模式可能用直接传进来的数据库名称而非本用例 Excel 中的数据，取消此验证
expectedConnect = TsUIConstants.ExpectedResult.SUCCESS;
} else {
assertTrue("无此模式：" + mode, false);
}
// 未取到某些值，且不是测试该为空的情况，自动取默认值
if (server.equals("") && expectedConnect != TsUIConstants.ExpectedResult.NO_SERVER) {
if (dbType != TsUIConstants.DB.INTERNAL) {
server = "localhost";
}
}
if (port.equals("") && expectedConnect != TsUIConstants.ExpectedResult.NO_PORT) {
if (dbType.equals(TsUIConstants.DB.MYSQL)) {
port = "3306";
} else if (dbType.equals(TsUIConstants.DB.ORACLE)) {
port = "1521";
} else if (dbType.equals(TsUIConstants.DB.POSTGRESQL)) {
port = "5432";
} else if (dbType.equals(TsUIConstants.DB.MSSQL)) {
port = "1433";
}
}
if (dbType.equals(TsUIConstants.DB.INTERNAL)) {
connectionName = path;
} else if (dbType.equals(TsUIConstants.DB.ORACLE)) {
connectionName = server + ":" + port + ":" + instance;
} else {
connectionName = server + ":" + port;
}
}
/**
* 从 Excel 文件中读取创建数据库相关数据，并赋值给成员变量;
*/
public void getDataCreateDB() {
getDataConnect(DatabaseManagementDialog.MANAGEMENT);
dbName = data.getTextOrEmpty(ExcelData.colDBName);
assertTrue("数据错误，数据库名称为 null。", dbName != null);
}
/**
* 从 Excel 文件中读取删除数据库相关数据，并赋值给成员变量;
*/
public void getDataDeleteDB() {
getDataCreateDB();
// confirm = data.getConfirm();
}
}
| 17,412 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
MemoryDBManagement.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.basecase/src/net/heartsome/cat/ts/test/basecase/menu/db/MemoryDBManagement.java | package net.heartsome.cat.ts.test.basecase.menu.db;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.basecase.common.ExcelData;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.DB;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.Entry;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.ExpectedResult;
import net.heartsome.cat.ts.test.ui.dialogs.CreateDatabaseDialog;
import net.heartsome.cat.ts.test.ui.dialogs.CreateMemoryDbDialog;
import net.heartsome.cat.ts.test.ui.dialogs.MemoryDatabaseManagementDialog;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.msgdialogs.ConfirmDialog;
import net.heartsome.cat.ts.test.ui.msgdialogs.InformationDialog;
import net.heartsome.cat.ts.test.ui.tasks.Waits;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.utils.SWTBotUtils;
import net.heartsome.test.swtbot.widgets.HsSWTBotTable;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import net.heartsome.test.utilities.sikuli.OsUtil;
import org.eclipse.jface.bindings.keys.KeyStroke;
import org.eclipse.jface.bindings.keys.ParseException;
import org.eclipse.swtbot.swt.finder.keyboard.Keystrokes;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 数据库的相关操作
* @author felix_lu
* @version
* @since JDK1.6
*/
/**
* @author Roy Xiao
* @version
* @since JDK1.6
*/
/**
* @author roy
*
*/
public class MemoryDBManagement {
private final TS ts = TS.getInstance();
private MemoryDatabaseManagementDialog dialog;
private DB dbType;
private String server;
private String port;
private String instance;
private String path;
private String username;
private String password;
private boolean saveConn = true;
private String dbName;
private HsRow rowDBData;
private ExcelData data;
private String connectionName;
private ExpectedResult expectedConnect = null;
private ExpectedResult expectedCreate = null;
// private boolean confirm = false;
private HsSWTBotTable table;
private int mode;
private boolean isFromImportDb = false;
/**
* true表示是记忆库， false表示是术语库
*/
private boolean isMemory = true;
/**
* @param isMemory the isMemory to set
*/
public void setMemory(boolean isMemory) {
this.isMemory = isMemory;
}
/**
* @param row
* 需要读取数据的 Excel 行。
*/
public MemoryDBManagement(HsRow row) {
rowDBData = row;
data = new ExcelData(row);
}
/**
* 完整流程：根据从 Excel 中读取的数据去连接数据库服务器;
* @param from
* 功能入口，请使用 TSUIConstants 类的枚举;
*/
public void connectServer(Entry from) {
mode = MemoryDatabaseManagementDialog.MANAGEMENT;
openDBMgmgDialog(from);
getDataConnect(mode);
getDBListFromServer(false);
dialog.btnClose().click();
// TODO 可增加对数据库数据的相关验证
}
/**
* 完整流程：根据从 Excel 中读取的数据去创建保存数据库服务器;
* @param from
* 功能入口，请使用 TSUIConstants 类的枚举;
*/
public void saveServer(Entry from) {
mode = MemoryDatabaseManagementDialog.MANAGEMENT;
openDBMgmgDialog(from);
getDataConnect(mode);
saveServer();
dialog.btnClose().click();
// TODO 可增加对数据库数据的相关验证
}
/**
* 完整步骤：根据从 Excel 中读取的数据删除已保存的连接信息
* @param from
* 功能入口，请使用 TSUIConstants 类的枚举;
*/
public void deleteConnection(Entry from) {
mode = MemoryDatabaseManagementDialog.MANAGEMENT;
openDBMgmgDialog(from);
getDataConnect(mode);
assertTrue("未在已保存的连接信息中找到该连接：" + connectionName, isConnectionSaved());
SWTBotTreeItem curDb = selectDBType();
int countBefore = curDb.getItems().length;
curDb.expandNode(connectionName).select();
dialog.btnRemoveConn().click();
int countRemove = curDb.getItems().length;
assertTrue("仍可在已保存的连接信息中找到该连接：" + connectionName, countBefore == countRemove+1 );
dialog.btnClose().click();
}
/**
* 完整流程：根据从 Excel 中读取的数据创建数据库;
* @param from
* 功能入口，请使用 TSUIConstants 类的枚举;
*/
public void createDB(Entry from) {
mode = MemoryDatabaseManagementDialog.MANAGEMENT;
openDBMgmgDialog(from);
getDataCreateDB();
selectDBType().expandNode(connectionName).select();
dialog.btnSearch().click();
// getDBListFromServer(true);
table = dialog.bot().table();
if (expectedCreate.equals(TsUIConstants.ExpectedResult.SUCCESS) && isExist(dbName)) { // 若预期结果为创建成功、而该数据库目前已存在，则先删除
table.unselect();
table.select(table.rowIndexOfColumn(dbName, TsUIConstants.getString("tblColDatabaseName")));
dialog.btnDeleteDb().click();
ConfirmDialog dlgConfirm = new ConfirmDialog(ConfirmDialog.dlgTitleTips,
ConfirmDialog.msgDeleteDatabaseFromServer);
dlgConfirm.btnOK().click();
Waits.shellClosed(dlgConfirm);
}
inputDBName();
if (expectedCreate.equals(TsUIConstants.ExpectedResult.SUCCESS)) {
assertTrue("列表中没有该数据库：" + dbName, isExist(dbName));
}
dialog.btnClose().click();
}
/**
* 完整流程：根据从 Excel 中读取的数据删除数据库;
* @param from
* 功能入口，请使用 TSUIConstants 类的枚举;
* @param confirm
* 是否确认删除
*/
public void deleteDB(Entry from, boolean confirm) {
mode = MemoryDatabaseManagementDialog.MANAGEMENT;
openDBMgmgDialog(from);
getDataDeleteDB();
// getDBListFromServer(true);
selectDBType().expandNode(connectionName).select();
dialog.btnSearch().click();
table = dialog.bot().table();
assertTrue("列表中没有该数据库：" + dbName, isExist(dbName));
table.unselect();
table.select(table.rowIndexOfColumn(dbName, TsUIConstants.getString("tblColDatabaseName")));
dialog.btnDeleteDb().click();
ConfirmDialog dlgConfirm = new ConfirmDialog(ConfirmDialog.dlgTitleTips,
ConfirmDialog.msgDeleteDatabaseFromServer);
if (confirm) {
dlgConfirm.btnOK().click();
Waits.shellClosed(dlgConfirm);
assertTrue("数据库仍在列表中：" + dbName, !isExist(dbName));
} else {
dlgConfirm.btnCancel().click();
Waits.shellClosed(dlgConfirm);
assertTrue("列表中没有该数据库：" + dbName, isExist(dbName));
}
dialog.btnClose().click();
}
/**
* 完整流程：根据从 Excel 中读取的数据删除数据库;
* @param from
* 功能入口，请使用 TSUIConstants 类的枚举;
*/
public void deleteDB(Entry from) {
deleteDB(from, data.getBoolean(ExcelData.colConfirm));
}
/**
* 完整流程：选择库;
* @param dbName
* 要选择的数据库名称，其他信息直接从 Excel 中读取
*/
public void selectDB(String dbName) {
mode = MemoryDatabaseManagementDialog.SELECT;
getDataConnect(mode);
dialog = new MemoryDatabaseManagementDialog(MemoryDatabaseManagementDialog.SELECT,isMemory?"dlgTitleMemoryManagement":"dlgTitletreiTbManagement");
dialog.activate();
getDBListFromServer(false);
assertTrue("数据库名称：" + dbName + "，实际内容：" + table.cell(0, 1), isExist(dbName));
table.unselect();
table.select(table.rowIndexOfColumn(dbName, TsUIConstants.getString("tblColDatabaseName")));
dialog.btnOK().click();
Waits.shellClosed(dialog);
}
// 以下为非完整步骤
/**
* @param from
* 入口，请使用 TSUIConstants 类中提供的枚举。
* @return 打开的库管理对话框;
*/
public MemoryDatabaseManagementDialog openDBMgmgDialog(Entry from) {
if (from.equals(TsUIConstants.Entry.MENU)) {
if (isMemory){
ts.menuDBManagement().click();
} else {
ts.menuTeriDBManagement().click();
}
} else if (from.equals(TsUIConstants.Entry.SHORTCUT)) {
try {
ts.pressShortcut(SWTBotUtils.getCtrlOrCmdKey(), Keystrokes.SHIFT, KeyStroke.getInstance("D"));
} catch (ParseException e) {
e.printStackTrace();
assertTrue("快捷键解析错误。", false);
}
} else {
assertTrue("参数错误，该功能无此入口：" + from, false);
}
dialog = new MemoryDatabaseManagementDialog(MemoryDatabaseManagementDialog.MANAGEMENT,isMemory?"dlgTitleMemoryManagement":"dlgTitletreiTbManagement");
return dialog;
}
/**
* 在库管理对话框左边的树上选择并展开指定类型的数据库;
* @return 指定数据库类型的树节点;
*/
public SWTBotTreeItem selectDBType() {
return selectDBType(dbType);
}
/**
* 在库管理对话框左边的树上选择并展开指定类型的数据库
* @param dbType
* 数据库类型;
* @return 指定数据库类型的树节点;
*/
public SWTBotTreeItem selectDBType(DB dbType) {
SWTBotTreeItem treei = null;
assertTrue("库管理对话框为 null。", dialog != null);
switch (dbType) {
case INTERNAL: {
treei = dialog.treiDBInternal().expand().select();
verifyInternalDBWidgets();
break;
}
case MYSQL: {
treei = dialog.treiDBMySQL().expand().select();
verifyExternalDBWidgets(dbType);
break;
}
case ORACLE: {
treei = dialog.treiDBOracle().expand().select();
verifyExternalDBWidgets(dbType);
break;
}
case POSTGRESQL: {
treei = dialog.treiDBPostgreSQL().expand().select();
verifyExternalDBWidgets(dbType);
break;
}
case MSSQL: {
treei = dialog.treiDBMSSQL().expand().select();
verifyExternalDBWidgets(dbType);
break;
}
default: {
assertTrue("无此数据库类型" + dbType, false);
}
}
return treei;
}
/**
* 确认选中内置库后，除路径和浏览按钮外，其他输入控件的状态为不可用;
*/
private void verifyInternalDBWidgets() {
dialog.btnAdd().click();
assertTrue(dialog.txtWLblPath().isEnabled());
assertTrue(dialog.btnBrowse().isEnabled());
assertTrue(!dialog.txtWLblServer().isEnabled());
assertTrue(!dialog.txtWLblPort().isEnabled());
assertTrue(!dialog.txtWLblInstance().isEnabled());
assertTrue(!dialog.txtWLblUsername().isEnabled());
assertTrue(!dialog.txtWLblPassword().isEnabled());
}
/**
* 确认选中外部库后，各输入控件的状态与内置库相反，及 Oracle 特有的实例
* @param dbType
* 数据库类型;
*/
private void verifyExternalDBWidgets(DB dbType) {
dialog.btnAdd().click();
assertTrue(dialog.txtWLblServer().isEnabled());
assertTrue(dialog.txtWLblPort().isEnabled());
assertTrue(dialog.txtWLblUsername().isEnabled());
assertTrue(dialog.txtWLblPassword().isEnabled());
assertTrue(!dialog.txtWLblPath().isEnabled());
assertTrue(!dialog.btnBrowse().isEnabled());
if (dbType.equals(TsUIConstants.DB.ORACLE)) {
assertTrue(dialog.txtWLblInstance().isEnabled());
} else {
assertTrue(!dialog.txtWLblInstance().isEnabled());
}
}
/**
* 往界面中填写服务器连接信息;
*/
public void setConnectionInfo() {
if (dbType.equals(TsUIConstants.DB.INTERNAL)) {
dialog.txtWLblPath().setText(path);
} else {
dialog.txtWLblServer().setText(server);
dialog.txtWLblPort().setText(port);
dialog.txtWLblUsername().setText(username);
dialog.txtWLblPassword().setText(password);
if (dbType.equals(TsUIConstants.DB.ORACLE)) {
dialog.txtWLblInstance().setText(instance);
}
}
// if (saveConn) {
// dialog.chkbxRemeber().select();
// }
}
/**
* 判断返回结果，并进行处理，
* @param isSave true 表示是保存连接操作，不需要考虑连接错误的； false 表示是查询连接操作。
* @param isFromImportDb true 表示是从导入记忆库界面打开的，数据库已经确保是对的，不用检查expectedConnect。
* @return true 表示需要保存连接 false 表示不需要保存连接，只对保存连接调用时起作用，查询连接调用此方法无需理会此返回值
*/
public boolean checkMsg(boolean isSave){
if (isFromImportDb){
return true;
}
if (expectedConnect.equals(TsUIConstants.ExpectedResult.SUCCESS)) {
assertTrue(HSBot.bot().activeShell().getText().equals(dialog.getText()));
return true;
} else {
InformationDialog msgDlg = null;
// 如果是保存操作，且返回值是连接错误，此时不用弹出提示框，直接返回true
if (isSave && expectedConnect == TsUIConstants.ExpectedResult.CONNECTION_ERROR) {
return true;
} else {
assertTrue(HSBot.bot().shells().length == 3);
}
switch (expectedConnect) {
case SUCCESS: {
break;
}
case NO_SERVER: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleErrorInfo,
InformationDialog.msgServerIsRequired);
break;
}
case NO_PORT: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleErrorInfo, InformationDialog.msgPortIsRequired);
break;
}
case NO_INSTANCE: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleErrorInfo,
InformationDialog.msgInstanceIsRequired);
break;
}
case NO_PATH: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleErrorInfo, InformationDialog.msgPathIsRequired);
break;
}
case NO_USERNAME: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleErrorInfo,
InformationDialog.msgUsernameIsRequired);
break;
}
case CONNECTION_ERROR: {
msgDlg = new InformationDialog(InformationDialog.dlgTitleTips,
InformationDialog.msgServerConnectionError);
break;
}
default: {
assertTrue("参数错误，无此预期结果：" + expectedConnect, false);
}
}
assertTrue(msgDlg.lblMessage().isVisible());
msgDlg.btnOK().click();
Waits.shellClosed(msgDlg);
return false;
}
}
/**
* 在数据库服务器上查询数据库列表
* @param useSavedConnection
* 是否使用已保存的连接;
* @return
*/
public HsSWTBotTable getDBListFromServer(boolean useSavedConnection) {
assertTrue("库管理对话框为 null。", dialog != null);
dialog.activate();
if (useSavedConnection && isConnectionSaved()) {
selectDBType().expandNode(connectionName).select();
dialog.btnAdd().click();
assertTrue("服务器地址未正确赋值。", server.equals(dialog.txtWLblServer().getText()));
assertTrue("服务器端口未正确赋值。", port.equals(dialog.txtWLblPort().getText()));
} else {
selectDBType();
setConnectionInfo();
dialog.btnSearch().click();
}
checkMsg(false);
table = dialog.bot().table();
return table;
}
/**
* 在数据库服务器上保存链接
* @return
*/
public void saveServer() {
assertTrue("库管理对话框为 null。", dialog != null);
dialog.activate();
int countBefore = selectDBType().getItems().length;
//点击添加按钮
dialog.btnAdd().click();
// 设置连接信息
setConnectionInfo();
assertTrue("服务器地址未正确赋值。", server.equals(dialog.txtWLblServer().getText()));
assertTrue("服务器端口未正确赋值。", port.equals(dialog.txtWLblPort().getText()));
//点击保存按钮
dialog.btnSaveConn().click();
int countNew = selectDBType().getItems().length;
//如果当前数据库类型的子节点已经增加了，则说明保存成功。
//checkMsg 返回 true 表示参数可以保存，对应的数据库类型节点的子集数量需要增加1， 如果为false，表示缺少必要的参数，不能保存，对应的数据库类型的子集数量应该不变。
if (checkMsg(true)){
assertTrue("保存连接错误1>"+dbType+":"+server+":"+port+":"+username,countNew== countBefore+1);
} else {
assertTrue("保存连接错误2>"+dbType+":"+server+":"+port+":"+username, countBefore == countNew);
};
}
/**
* @return 是否能在该数据库类型下找到名为 指定服务器:端口号 的已保存连接;
*/
public boolean isConnectionSaved() {
SWTBotTreeItem[] items = selectDBType().getItems();
for (SWTBotTreeItem item : items) {
if (item.getText().equals(connectionName)) {
return true;
}
}
return false;
}
/**
* @return 在当前对话框中验证该数据库是否存在;
*/
public boolean isExist(String dbName) {
return table.containsTextInColumn(dbName, TsUIConstants.getString("tblColDatabaseName"));
}
/**
* 未打开库管理对话框时，直接验证数据库是否存在
* @param dbName
* 要验证的数据库名称
* @param closeDlg
* 是否在获取结果后关闭对话框
* @return 若该数据库存在则返回 true，否则为 false;
*/
public boolean isDBExist(String dbName, boolean closeDlg) {
mode = MemoryDatabaseManagementDialog.SELECT;
openDBMgmgDialog(TsUIConstants.Entry.MENU);
getDataConnect(mode);
getDBListFromServer(false);
boolean result = table.containsTextInColumn(dbName, dialog.tblColDatabaseName());
if (closeDlg) {
closeDialog();
}
return result;
}
/**
* 输入数据库名称，含项目名称合法性校验;
*/
public void inputDBName() {
assertTrue(dialog.btnCreateDb().isEnabled());
dialog.btnCreateDb().click();
CreateMemoryDbDialog dlgInputDBName = new CreateMemoryDbDialog(isMemory?"dlgTitleCreateMemoryDatabase":"dlgTitleCreatetreiTbDatabase");
dlgInputDBName.txtWLblDatabaseName().setText(dbName);
dlgInputDBName.btnOK().click();
switch (expectedCreate) {
case INVALID_NAME: {
assertTrue("未正确显示名称非法信息。", dlgInputDBName.msgDBNameInvalid().isVisible());
dlgInputDBName.btnCancel().click();
break;
}
case DUPLICATED_NAME: {
assertTrue("未正确显示重名信息。", dlgInputDBName.msgDBExists().isVisible());
dlgInputDBName.btnCancel().click();
break;
}
case LONG_NAME: {
assertTrue("未正确显示名称过长信息。", dlgInputDBName.msgDBNameTooLong().isVisible());
dlgInputDBName.btnCancel().click();
break;
}
}
Waits.shellClosed(dlgInputDBName);
}
/**
* 关闭库管理对话框;
*/
public void closeDialog() {
dialog.btnClose().click();
}
// 以下为读取 Excel 文件中的测试数据相关方法
/**
* 从 Excel 文件中读取连接数据库服务器相关数据，并赋值给成员变量;
*/
public void getDataConnect(int mode) {
assertTrue("参数错误：Excel 列为 null。", rowDBData != null);
dbType = data.getDBType();
server = data.getTextOrEmpty(ExcelData.colServer);
port = data.getTextOrEmpty(ExcelData.colPort);
instance = data.getTextOrEmpty(ExcelData.colInstance);
path = data.getTextOrEmpty(ExcelData.colDBPath);
username = data.getTextOrEmpty(ExcelData.colUsername);
password = data.getTextOrEmpty(ExcelData.colPassword);
saveConn = data.getBoolean(ExcelData.colSaveConn);
if (mode == MemoryDatabaseManagementDialog.MANAGEMENT) {
expectedCreate = data.getExpectedResult();
if (expectedCreate.equals(TsUIConstants.ExpectedResult.INVALID_NAME)
|| expectedCreate.equals(TsUIConstants.ExpectedResult.DUPLICATED_NAME)
|| expectedCreate.equals(TsUIConstants.ExpectedResult.LONG_NAME)) {
expectedConnect = TsUIConstants.ExpectedResult.SUCCESS; // 创建失败，隐含连接成功
} else {
expectedConnect = data.getExpectedResult();
}
} else if (mode == MemoryDatabaseManagementDialog.SELECT) {
dbName = data.getTextOrEmpty(ExcelData.colDBName);
// assertTrue(dbName != null); 因选择模式可能用直接传进来的数据库名称而非本用例 Excel 中的数据，取消此验证
expectedConnect = TsUIConstants.ExpectedResult.SUCCESS;
} else {
assertTrue("无此模式：" + mode, false);
}
// 未取到某些值，且不是测试该为空的情况，自动取默认值
if (server.equals("") && expectedConnect != TsUIConstants.ExpectedResult.NO_SERVER) {
if (dbType != TsUIConstants.DB.INTERNAL) {
server = "localhost";
}
}
if (port.equals("") && expectedConnect != TsUIConstants.ExpectedResult.NO_PORT) {
if (dbType.equals(TsUIConstants.DB.MYSQL)) {
port = "3306";
} else if (dbType.equals(TsUIConstants.DB.ORACLE)) {
port = "1521";
} else if (dbType.equals(TsUIConstants.DB.POSTGRESQL)) {
port = "5432";
} else if (dbType.equals(TsUIConstants.DB.MSSQL)) {
port = "1433";
}
}
if (dbType.equals(TsUIConstants.DB.INTERNAL)) {
connectionName = path;
} else if (dbType.equals(TsUIConstants.DB.ORACLE)) {
connectionName = server + ":" + port + "/" + instance;
} else {
connectionName = server + ":" + port;
}
}
/**
* 从 Excel 文件中读取创建数据库相关数据，并赋值给成员变量;
*/
public void getDataCreateDB() {
getDataConnect(MemoryDatabaseManagementDialog.MANAGEMENT);
dbName = data.getTextOrEmpty(ExcelData.colDBName);
assertTrue("数据错误，数据库名称为 null。", dbName != null);
}
/**
* 从 Excel 文件中读取删除数据库相关数据，并赋值给成员变量;
*/
public void getDataDeleteDB() {
getDataCreateDB();
// confirm = data.getConfirm();
}
public void setFromImportDb(boolean isFromImportDb) {
this.isFromImportDb = isFromImportDb;
}
}
| 21,301 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ProjectSetting.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.basecase/src/net/heartsome/cat/ts/test/basecase/menu/project/ProjectSetting.java | package net.heartsome.cat.ts.test.basecase.menu.project;
import static org.junit.Assert.assertTrue;
import java.util.Arrays;
import java.util.List;
import net.heartsome.cat.ts.test.basecase.common.ExcelData;
import net.heartsome.cat.ts.test.basecase.menu.db.DBManagement;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.Entry;
import net.heartsome.cat.ts.test.ui.dialogs.ProjectSettingDialog;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.msgdialogs.InformationDialog;
import net.heartsome.cat.ts.test.ui.tasks.Waits;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException;
/**
* 封装项目设置的常用方法
* @author felix_lu
* @version
* @since JDK1.6
*/
public class ProjectSetting {
private ProjectSettingDialog dlgPrjSetting;
private HsRow row;
private ExcelData data;
private String name;
private String client;
private String company;
private String eMail;
private String remark;
private String srcLang;
private String[] tgtLangs;
// private int dbType;
private String tMDBName;
private String tBDBName;
// private String address;
private boolean isTMDBExist;
private boolean isTBDBExist;
/**
* 设置之后的动作
* @author felix_lu
* @version
* @since JDK1.6
*/
public enum NextAction {
OK, CANCEL, WAIT,
}
/**
* @param row
* 存放测试数据的 Excel 表格行对象
*/
public ProjectSetting(HsRow row) {
this.row = row;
data = new ExcelData(row);
}
/**
* 完整的设置项目信息流程，含确定并关闭对话框
* @param from
* ;
*/
public void setProjectInfo(Entry from) {
// getDataPrjSetting();
// openPrjSettingDlg(from);
setPrjBasicInfo(from, NextAction.WAIT);
setPrjLangs(from, NextAction.WAIT);
setTMDB(from, NextAction.WAIT);
setTBDB(from, NextAction.WAIT);
nextAction(NextAction.OK);
}
/**
* 打开项目设置对话框
* @param from
* 功能入口，请使用 TSUIConstants 类提供的常量
* @return 项目设置对话框对象;
*/
public ProjectSettingDialog openPrjSettingDlg(Entry from) {
if (name == null) {
getDataPrjSetting();
}
assertTrue(name != null && !name.equals(""));
ProjectTreeView.getTree().expandNode(name).select();
switch (from) {
case CONTEXT_MENU: {
ProjectTreeView.getInstance().ctxMenuProjectSetting().click();
break;
}
case MENU: {
TS.getInstance(); // TODO
break;
}
case SHORTCUT: {
// TODO
break;
}
default: {
assertTrue("无此入口：" + from, false);
}
}
dlgPrjSetting = new ProjectSettingDialog();
assertTrue(dlgPrjSetting.isActive());
return dlgPrjSetting;
}
/**
* 设置项目基本信息
* @param from
* 功能入口，请使用 TSUIConstants 类提供的常量;
* @param wait
* 下一步操作，请使用本类提供的常量;
*/
public void setPrjBasicInfo(Entry from, NextAction wait) {
if (dlgPrjSetting == null) {
openPrjSettingDlg(from);
}
dlgPrjSetting.treiProjectInfo().expand().select();
dlgPrjSetting.txtWLblClient().setText(client);
dlgPrjSetting.txtWLblCompany().setText(company);
dlgPrjSetting.txtWLblEMail().setText(eMail);
dlgPrjSetting.txtWLblRemark().setText(remark);
nextAction(wait);
}
/**
* 设置项目语言
* @param from
* 功能入口，请使用 TSUIConstants 类提供的常量;
* @param wait
* 下一步操作，请使用本类提供的常量;
*/
public void setPrjLangs(Entry from, NextAction wait) {
if (dlgPrjSetting == null) {
openPrjSettingDlg(from);
}
dlgPrjSetting.treiProjectLanguage().select();
if (!srcLang.equals(dlgPrjSetting.cmbSrcLang().selection())) {
dlgPrjSetting.cmbSrcLang().setSelection(srcLang);
}
dlgPrjSetting.lstTgtLangAvailable().select(tgtLangs);
dlgPrjSetting.btnAddToRight().click();
List<String> selectedLangs = Arrays.asList(dlgPrjSetting.lstTgtLangSelected().selection());
for (String tgtLang : tgtLangs) {
assertTrue(selectedLangs.contains(tgtLang));
}
nextAction(wait);
}
/**
* 设置记忆库
* @param from
* 功能入口，请使用 TSUIConstants 类提供的常量;
* @param nextAction
* 下一步操作，请使用本类提供的常量;
*/
public void setTMDB(Entry from, NextAction nextAction) {
if (dlgPrjSetting == null) {
openPrjSettingDlg(from);
}
dlgPrjSetting.treiTmSetting().select();
if (!dlgPrjSetting.table().containsTextInColumn(tMDBName, dlgPrjSetting.tblColName())) {
if (isTMDBExist) {
dlgPrjSetting.btnAdd().click();
DBManagement dbMgmt = new DBManagement(row);
dbMgmt.selectDB(tMDBName);
} else {
dlgPrjSetting.btnCreate().click();
// TODO 目前弹出的是数据库创建向导，而该向导有较大的改进余地，暂不实现
}
try {
InformationDialog dlgInfo = new InformationDialog(InformationDialog.dlgTitleTips,
InformationDialog.msgNoMatchInDB);
dlgInfo.btnOK().click();
Waits.shellClosed(dlgInfo);
} catch (WidgetNotFoundException e) {
// e.printStackTrace();
}
assertTrue("未正确选择记忆库：" + tMDBName,
dlgPrjSetting.table().containsTextInColumn(tMDBName, dlgPrjSetting.tblColName()));
}
nextAction(nextAction);
}
/**
* 设置术语库
* @param from
* 功能入口，请使用 TSUIConstants 类提供的常量;
* @param nextAction
* 下一步操作，请使用本类提供的常量;
*/
public void setTBDB(Entry from, NextAction nextAction) {
if (dlgPrjSetting == null) {
openPrjSettingDlg(from);
}
dlgPrjSetting.treiTbSetting().select();
if (!dlgPrjSetting.table().containsTextInColumn(tBDBName, dlgPrjSetting.tblColName())) {
if (isTBDBExist) {
dlgPrjSetting.btnAdd().click();
DBManagement dbMgmt = new DBManagement(row);
dbMgmt.selectDB(tBDBName);
} else {
dlgPrjSetting.btnCreate().click();
// TODO 同上
}
try {
InformationDialog dlgInfo = new InformationDialog(InformationDialog.dlgTitleTips,
InformationDialog.msgNoMatchInDB);
dlgInfo.btnOK().click();
Waits.shellClosed(dlgInfo);
} catch (WidgetNotFoundException e) {
e.printStackTrace();
}
assertTrue("未正确选择术语库：" + tBDBName,
dlgPrjSetting.table().containsTextInColumn(tBDBName, dlgPrjSetting.tblColName()));
}
nextAction(nextAction);
}
/**
* 操作完成后的下一步动作
* @param nextAction
* 动作代码，本类常量;
*/
private void nextAction(NextAction nextAction) {
switch (nextAction) {
case OK: {
dlgPrjSetting.btnOK().click();
Waits.shellClosed(dlgPrjSetting);
break;
}
case CANCEL: {
dlgPrjSetting.btnCancel().click();
Waits.shellClosed(dlgPrjSetting);
break;
}
case WAIT: {
break;
}
default: {
assertTrue("参数错误，无此下一步操作：" + nextAction, false);
}
}
}
/**
* 从 Excel 文件中读取测试数据并赋值给相应变量;
*/
private void getDataPrjSetting() {
name = data.getTextOrEmpty(ExcelData.colPrjName);
client = data.getTextOrEmpty(ExcelData.colClient);
company = data.getTextOrEmpty(ExcelData.colCompany);
eMail = data.getTextOrEmpty(ExcelData.colEMail);
remark = data.getTextOrEmpty(ExcelData.colRemark);
srcLang = TsUIConstants.getLang(data.getTextOrEmpty(ExcelData.colSrcLang));
tgtLangs = TsUIConstants.getLangs(data.getTextArray(ExcelData.colTgtLang));
// dbType = data.getDBType();
tMDBName = data.getTextOrEmpty(ExcelData.colTMDBName);
tBDBName = data.getTextOrEmpty(ExcelData.colTBDBName);
// address = data.getServer();
DBManagement dbMgmt = new DBManagement(row);
isTMDBExist = dbMgmt.isDBExist(tMDBName, false);
isTBDBExist = dbMgmt.isExist(tBDBName);
dbMgmt.closeDialog();
}
}
| 8,012 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ProjectRename.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.basecase/src/net/heartsome/cat/ts/test/basecase/menu/file/ProjectRename.java | package net.heartsome.cat.ts.test.basecase.menu.file;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.basecase.common.ExcelData;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.Entry;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.ExpectedResult;
import net.heartsome.cat.ts.test.ui.dialogs.ProjectExistsDialog;
import net.heartsome.cat.ts.test.ui.dialogs.RenameProblemsDialog;
import net.heartsome.cat.ts.test.ui.tasks.Waits;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import org.eclipse.swtbot.swt.finder.keyboard.Keystrokes;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
/**
* 项目相关操作
* @author felix_lu
*/
public class ProjectRename {
// /** 刷新文件系统时的最大重试次数 */
// private static final int MAX_RETRY = 10;
/** 重命名项目相关数据 */
// private HsRow rowRenamePrjData;
private String oldName;
private String newName;
private ExpectedResult expectedResult;
private String invalidChar;
private boolean overwrite;
private ExcelData data;
private ProjectTreeView viewPrjTree = ProjectTreeView.getInstance();
private SWTBotTree treePrj = ProjectTreeView.getTree();
/**
*
*/
public ProjectRename() {
}
/**
* @param rowRenamePrjData
*/
public ProjectRename(HsRow rowRenamePrjData) {
// this.rowRenamePrjData = rowRenamePrjData;
data = new ExcelData(rowRenamePrjData);
}
/**
* 重命名项目
* @param oldName
* 旧项目名称
* @param newName
* 新项目名称
*/
private void renamePrj(Entry from, String oldName, String newName, ExpectedResult expectedResult,
String invalidChar, boolean overwrite) {
// 先取消选中项目，避免后面没有找到匹配项目时仍有之前选中的项目被误操作
treePrj.unselect();
Waits.prjExistOnTree(oldName);
// 选择项目并重命名
treePrj.select(oldName);
switch (from) {
case CONTEXT_MENU: {
viewPrjTree.ctxMenuRename().click();
break;
}
case SHORTCUT: {
treePrj.pressShortcut(Keystrokes.F2);
break;
}
default: {
assertTrue("错误的入口参数：" + from, false);
}
}
// 进入重命名状态
SWTBotText txtPrjName = viewPrjTree.bot().text(oldName);
// 输入新名称并回车确认
txtPrjName.typeText(newName + "\n");
/* 以下为异常情况处理及重命名结果验证部分 */
// 若有多余的对话框，说明两种可能：一是出现进度对话框；二是重命名出现了问题（如文件系统不同步）。
// 不同步的问题暂不考虑——若要解决，思路是判断是否出现不同步的信息，若有则刷新后重试重命名，直到达到最大重试次数后放弃。
if (HSBot.bot().shells().length > 1) { // FIXME: 可能需要修改这种判断方式，试试 activeShell()?
Waits.progressFinished();
String title = HSBot.bot().activeShell().getText();
String errMsg = "重命名出错。对话框标题：" + title;
switch (expectedResult) {
case SUCCESS: {
// 验证结果
assertRenamed(oldName, newName);
break;
}
case INVALID_NAME: {
if (title.equals(TsUIConstants.getString("dlgTitleRenameProblems"))) {
RenameProblemsDialog rpd = new RenameProblemsDialog(newName, invalidChar);
assertTrue("未正确显示项目名非法的信息。", rpd.isInvalidMsgVisible());
assertTrue(rpd.btnOK().isEnabled());
rpd.btnOK().click();
Waits.shellClosed(rpd);
assertNotRenamed(oldName, newName);
} else {
assertTrue(errMsg, false);
}
break;
}
case DUPLICATED_NAME: {
if (title.equals(TsUIConstants.getString("dlgTitleProjectExists"))) {
ProjectExistsDialog ped = new ProjectExistsDialog(newName);
assertTrue("未正确显示项目名称已存在的信息。", ped.isProjectExistsMsgVisible());
assertTrue(ped.btnYes().isEnabled());
assertTrue(ped.btnNo().isEnabled());
if (overwrite) {
ped.btnYes().click();
Waits.shellClosed(ped);
Waits.progressFinished();
assertRenamed(oldName, newName);
} else {
ped.btnNo().click();
Waits.shellClosed(ped);
Waits.progressFinished();
assertNotOverwritten(oldName, newName);
}
} else {
assertTrue(errMsg, false);
}
break;
}
default: {
assertTrue(errMsg, false);
}
}
} else { // 重命名正常，验证结果
assertRenamed(oldName, newName);
}
}
/**
* 根据从 Excel 文件里读取到的数据，重命名项目;
*/
public void renamePrj(Entry from) {
getDataNames();
renamePrj(from, oldName, newName, expectedResult, invalidChar, overwrite);
}
/**
* 断言（等待）成功重命名，即旧项目不存在、新项目存在
* @param oldName
* @param newName
*/
private void assertRenamed(String oldName, String newName) {
treePrj.unselect();
Waits.prjNotExistOnTree(oldName);
Waits.prjNotExistInWorkspace(oldName);
Waits.prjExistOnTree(newName);
Waits.prjExistInWorkspace(newName);
}
/**
* 断言（等待）未重命名，即旧项目存在、新项目不存在
* @param oldName
* @param newName
*/
private void assertNotRenamed(String oldName, String newName) {
treePrj.unselect();
Waits.prjExistOnTree(oldName);
Waits.prjExistInWorkspace(oldName);
Waits.prjNotExistOnTree(newName);
Waits.prjNotExistInWorkspace(newName);
}
/**
* 断言（等待）未覆盖，即新、旧名称的项目均存在
* @param oldName
* @param newName
*/
private void assertNotOverwritten(String oldName, String newName) {
treePrj.unselect();
Waits.prjExistOnTree(oldName);
Waits.prjExistInWorkspace(oldName);
Waits.prjExistOnTree(newName);
Waits.prjExistInWorkspace(newName);
}
/**
* 从 Excel 文件中取重命名项目的数据，并赋值给相应的成员变量;
*/
public void getDataNames() {
oldName = data.getTextOrEmpty(ExcelData.colOldName);
newName = data.getTextOrEmpty(ExcelData.colNewName);
expectedResult = data.getExpectedResult();
invalidChar = data.getTextOrEmpty(ExcelData.colInvChar);
overwrite = data.getBoolean(ExcelData.colOverwrite);
}
}
| 6,405 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ProjectFile.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.basecase/src/net/heartsome/cat/ts/test/basecase/menu/file/ProjectFile.java | package net.heartsome.cat.ts.test.basecase.menu.file;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.basecase.common.ExcelData;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.Entry;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.ResourceType;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.utils.TreeItemUtil;
import net.heartsome.test.swtbot.waits.IsFileOpenedInEditor;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
/**
* 对项目文件夹、文件的一些操作，主要基于项目导航树。
* @author felix_lu
* @version
* @since JDK1.6
*/
public class ProjectFile {
private HsRow row;
private String prjName;
private String fileType;
private String filePath;
private String fileName;
// private int expResult;
private ExcelData data;
private ProjectTreeView view;
private SWTBotTree tree;
private SWTBotTreeItem treeItem;
private ResourceType selectType;
/**
* @param row
* 存放测试数据的 Excel 行
*/
public ProjectFile(HsRow row) {
this.row = row;
view = ProjectTreeView.getInstance();
tree = ProjectTreeView.getTree();
data = new ExcelData(row);
}
/**
* @param from
* 打开文件的入口：右键菜单、双击，请使用 TS 类提供的常量;
*/
public void openFile(Entry from) {
assertTrue("参数错误，Excel 数据行 row 为 null。", row != null);
getDataFile();
SWTBotTreeItem item = select();
assertTrue("如下选择类型不是文件：" + selectType, selectType == TsUIConstants.ResourceType.FILE);
switch (from) {
case DOUBLE_CLICK: {
item.doubleClick();
break;
}
case CONTEXT_MENU: {
view.ctxMenuOpenFile().click();
break;
}
default: {
assertTrue("参数错误，无此入口：" + from, false);
}
}
HSBot.bot().waitUntil(new IsFileOpenedInEditor(fileName));
}
// TODO
/**
* @return 选中的项目、文件类型（文件夹）、子文件夹或文件所在的项目导航树节点;
*/
public SWTBotTreeItem select() {
if (prjName == null) {
getDataFile();
}
if (fileType == null || fileType.equals("")) { // 文件类型为空，说明只选项目
treeItem = tree.expandNode(prjName).select();
selectType = TsUIConstants.ResourceType.PROJECT;
} else {
if (filePath != null && !filePath.equals("")) { // 在指定的类型下还有子文件夹
String[] paths = filePath.split("/");
if (fileName != null && !fileName.equals("")) { // 文件名不为空，则选择文件
treeItem = tree.expandNode(prjName).expandNode(fileType).expandNode(paths).expandNode(fileName)
.select();
selectType = TsUIConstants.ResourceType.FILE;
} else { // 文件名为空，即只选指定文件类型文件夹下的子文件夹
treeItem = tree.expandNode(prjName).expandNode(fileType).expandNode(paths).select();
selectType = TsUIConstants.ResourceType.FOLDER;
}
} else { // 直接在在指定的类型下，没有子文件夹
if (fileName != null && !fileName.equals("")) { // 文件名不为空，则选择文件
treeItem = tree.expandNode(prjName).expandNode(fileType).expandNode(fileName).select();
selectType = TsUIConstants.ResourceType.FILE;
} else { // 文件名为空，即选择该文件类型文件夹
treeItem = tree.expandNode(prjName).expandNode(fileType).select();
selectType = TsUIConstants.ResourceType.FOLDER;
}
}
}
return treeItem;
}
/**
* @return 取得当前文件在工作空间中的路径;
*/
public String getPath() {
if (treeItem == null) {
select();
}
return TreeItemUtil.getPath(treeItem);
}
/**
* 从 Excel 文件中读取打开文件所需的测试数据;
*/
public void getDataFile() {
assertTrue("参数错误，row 为 null。", row != null);
prjName = data.getTextOrEmpty(ExcelData.colPrjName);
fileType = data.getTextOrEmpty(ExcelData.colFileType);
filePath = data.getTextOrEmpty(ExcelData.colFilePath);
fileName = data.getTextOrEmpty(ExcelData.colFileName);
// expResult = data.getExpectedResult();
}
}
| 4,370 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ProjectCreate.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.basecase/src/net/heartsome/cat/ts/test/basecase/menu/file/ProjectCreate.java | package net.heartsome.cat.ts.test.basecase.menu.file;
import static org.junit.Assert.assertTrue;
import java.io.File;
import net.heartsome.cat.ts.test.basecase.common.ExcelData;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.Entry;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.ExpectedResult;
import net.heartsome.cat.ts.test.ui.dialogs.FileNewDialog;
import net.heartsome.cat.ts.test.ui.dialogs.NewProjectDialog;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.tasks.Waits;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import net.heartsome.test.swtbot.utils.SWTBotUtils;
import net.heartsome.test.utilities.common.FileUtil;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import org.eclipse.jface.bindings.keys.KeyStroke;
import org.eclipse.jface.bindings.keys.ParseException;
/**
* 项目相关操作
* @author felix_lu
*/
public class ProjectCreate {
private final TS ts = TS.getInstance();
/**
* 下一步操作
* @author felix_lu
* @version
* @since JDK1.6
*/
public enum NextAction {
CANCEL, BACK, NEXT, FINISH,
}
/** 创建向导的对话框 shell. */
private NewProjectDialog dialog;
/** 创建项目信息相关数据 */
private HsRow rowCreatePrjData;
private ExcelData data;
private String name;
private String remark;
private String client;
private String company;
private String eMail;
private String srcLangCode;
private String[] tgtLangCodes;
// private List<String[]> dbTMs;
// private List<String[]> dbTBs;
// private String[] srcFiles;
private ExpectedResult expectedResult;
private String invalidChar;
/**
*
*/
public ProjectCreate() {
}
/**
* @param rowCreatePrjData
*/
public ProjectCreate(HsRow rowCreatePrjData) {
this.rowCreatePrjData = rowCreatePrjData;
data = new ExcelData(rowCreatePrjData);
}
/**
* @param name
* @param srcLangCode
* @param tgtLangCodes
*/
public ProjectCreate(String name, String srcLangCode, String... tgtLangCodes) {
this.name = name;
this.srcLangCode = srcLangCode;
this.tgtLangCodes = tgtLangCodes;
}
/**
* 从指定的入口打开新建对话框
* @param from
* @throws ParseException
*/
public void openCreateProjectDialog(Entry from) {
switch (from) {
case MENU: {
ts.menuFileNewProject().click();
dialog = new NewProjectDialog(FileNewDialog.NEW_TYPE_PROJECT);
break;
}
case SHORTCUT: {
try {
ProjectTreeView.getTree().pressShortcut(SWTBotUtils.getCtrlOrCmdKey(), KeyStroke.getInstance("N"));
} catch (ParseException e) {
assertTrue("快捷键解析错误。", false);
}
dialog = new NewProjectDialog(FileNewDialog.NEW);
break;
}
case CONTEXT_MENU: {
ProjectTreeView.getTree().contextMenu("新建记忆库...").click();
// ProjectTreeView.getInstance().ctxMenuNewProject().click();
dialog = new NewProjectDialog(FileNewDialog.NEW);
break;
}
// case CONTEXT_MENU_ALT: {
// ProjectTreeView.getInstance().ctxMenuNewProject().click();
// dialog = new NewProjectDialog(FileNewDialog.NEW_TYPE_PROJECT);
// break;
// }
default: {
assertTrue("参数错误：创建项目入口 from 不正确。", false);
}
}
assertTrue(dialog.isActive());
// 选择新建类型为 Project，下一步
// dialog.treeiProject().select();
// assertTrue(dialog.btnNext().isEnabled());
// dialog.btnNext().click();
}
/**
* 创建项目第一步：基本信息;
* @param nextAction
* 向导方向，请使用常量;
*/
public void createPrj1BasicInfo(NextAction nextAction, ExpectedResult expectedResult, String invalidChar) {
assertTrue("参数错误：项目名称为 null。", name != null);
dialog.setBasicInfo(name, remark, client, company, eMail);
switch (nextAction) {
case BACK: {
assertTrue(dialog.btnBack().isEnabled());
dialog.btnBack().click();
break;
}
case NEXT: {
switch (expectedResult) {
case SUCCESS: {
assertTrue(dialog.btnNext().isEnabled());
dialog.btnNext().click();
break;
}
case DUPLICATED_NAME: {
assertTrue(!dialog.btnNext().isEnabled());
assertTrue(dialog.msgDucplicatedProjectName().isVisible());
break;
}
case INVALID_NAME: {
assertTrue(!dialog.btnNext().isEnabled());
assertTrue(dialog.msgInvalidCharInResourceName(invalidChar, name).isVisible());
break;
}
default: {
assertTrue("参数错误：expectedResult 不正确。", false);
}
}
break;
}
default: {
assertTrue("参数错误：nextAction 不正确。", false);
}
}
}
/**
* 创建项目第二步：语言对;
* @param nextAction
* 向导方向，请使用常量;
*/
public void createPrj2LangPair(NextAction nextAction) {
assertTrue("参数错误：项目源语言为 null。", srcLangCode != null);
assertTrue("参数错误：项目目标语言为 null。", tgtLangCodes != null);
for (String tgtLangCode : tgtLangCodes) {
assertTrue("参数错误：项目目标语言为 null。", tgtLangCode != null);
}
dialog.setLangPair(srcLangCode, tgtLangCodes);
switch (nextAction) {
case BACK: {
dialog.btnBack().isActive();
dialog.btnBack().click();
break;
}
case NEXT: {
dialog.btnNext().isActive();
dialog.btnNext().click();
break;
}
case FINISH: {
dialog.btnFinish().isActive();
dialog.btnFinish().click();
break;
}
default: {
assertTrue("参数错误：nextAction 不正确。", false);
}
}
}
/**
* 直接从指定的 Excel 表格行中读取数据并创建项目。
* @param from
* ;
* @throws ParseException
*/
public void createPrj(Entry from) {
assertTrue("参数错误：Excel 表格数据为 null。", rowCreatePrjData != null);
openCreateProjectDialog(from);
getDataBasicInfo();
if (expectedResult.equals(TsUIConstants.ExpectedResult.SUCCESS)) { // 预期结果为创建成功的话，需要先删除可能以前创建过但未删除的项目目录，避免影响后面的创建结果
File oldPrjFile = new File(FileUtil.joinPath(FileUtil.getWorkspacePath(), name));
FileUtil.deleteIfExist(oldPrjFile);
}
createPrj1BasicInfo(NextAction.NEXT, expectedResult, invalidChar);
if (expectedResult.equals(TsUIConstants.ExpectedResult.SUCCESS)) {
getDataLangPairs();
createPrj2LangPair(NextAction.FINISH);
Waits.shellClosed(dialog);
Waits.prjExistOnTree(name);
Waits.prjExistInWorkspace(name);
} else {
dialog.btnCancel().click();
Waits.shellClosed(dialog);
}
}
// /**
// * @param from
// * @param prjBasicInfo
// * @param srcLangCode
// * @param tgtLangCodes
// * @param dbTMs
// * @param dbTB
// * @param srcFiles
// * ;
// * @throws ParseException
// */
// public void createPrj(int from, String name, String remark, String client, String company, String eMail,
// String srcLangCode, List<String> tgtLangCodes, List<String[]> dbTMs, List<String[]> dbTB,
// List<String[]> srcFiles) throws ParseException {
// openCreateProjectDialog(from);
// dialog.setBasicInfo(name, remark, client, company, eMail);
// dialog.btnNext().isActive();
// dialog.btnNext().click();
// dialog.setLangPair(srcLangCode, tgtLangCodes);
// dialog.btnFinish().isActive();
// dialog.btnFinish().click();
// Waits.shellClosed(dialog);
// Waits.prjExist(name);
// }
/**
* 从 Excel 文件中取项目基本信息数据，并赋值给相应的成员变量;
*/
public void getDataBasicInfo() {
name = data.getTextOrEmpty(ExcelData.colPrjName);
remark = data.getTextOrEmpty(ExcelData.colRemark);
client = data.getTextOrEmpty(ExcelData.colClient);
company = data.getTextOrEmpty(ExcelData.colCompany);
eMail = data.getTextOrEmpty(ExcelData.colEMail);
expectedResult = data.getExpectedResult();
invalidChar = data.getTextOrEmpty(ExcelData.colInvChar);
}
/**
* 从 Excel 指定序号的行中读取语言对数据，并赋值给相应的成员变量;
*/
public void getDataLangPairs() {
srcLangCode = data.getTextOrEmpty(ExcelData.colSrcLang);
tgtLangCodes = data.getTextArray(ExcelData.colTgtLang);
}
}
| 8,159 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ProjectDelete.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.basecase/src/net/heartsome/cat/ts/test/basecase/menu/file/ProjectDelete.java | package net.heartsome.cat.ts.test.basecase.menu.file;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.basecase.common.ExcelData;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.Entry;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.msgdialogs.ConfirmProjectDeleteDialog;
import net.heartsome.cat.ts.test.ui.msgdialogs.ProgressDialog;
import net.heartsome.cat.ts.test.ui.tasks.Waits;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
/**
* 项目相关操作
* @author felix_lu
*/
public class ProjectDelete {
/** 创建项目信息相关数据 */
// private HsRow rowDeletePrjData;
private String name;
private boolean deleteContent;
// private int expectedResult;
private ExcelData data;
/**
*
*/
public ProjectDelete() {
}
/**
* @param rowDeletePrjData
*/
public ProjectDelete(HsRow rowDeletePrjData) {
// this.rowDeletePrjData = rowDeletePrjData;
data = new ExcelData(rowDeletePrjData);
}
/**
* @param name
* @param deleteContent
*/
public ProjectDelete(String name, boolean deleteContent) {
this.name = name;
this.deleteContent = deleteContent;
}
/**
* @param from
* 从指定的入口、按照从 Excel 中读取的数据删除项目;
*/
public void deletePrj(Entry from) {
getDataDeleteProject();
deletePrj(from, name, deleteContent);
}
/**
* 删除项目
* @param name
* 项目名称
* @param deleteContent
* 是否同时删除项目文件夹
*/
public void deletePrj(Entry from, String name, boolean deleteContent) {
ProjectTreeView ptv = ProjectTreeView.getInstance();
SWTBotTree treePrj = ProjectTreeView.getTree();
Waits.prjExistOnTree(name);
treePrj.unselect(); // 取消选中任何项目，避免误操作
// 选择项目并删除
treePrj.select(name).isActive();
switch (from) {
case CONTEXT_MENU: {
ptv.ctxMenuDelete().click();
break;
}
case MENU: {
TS.getInstance().menuEditDelete().click();
break;
}
default: {
assertTrue("无此入口：" + from, false);
}
}
// 确认删除对话框
ConfirmProjectDeleteDialog cpd = new ConfirmProjectDeleteDialog(name);
cpd.isActive();
// 选择是否删除内容
if (deleteContent) {
cpd.radBtnAlsoDeleteContentsUnder().click();
cpd.btnYes().click();
Waits.shellClosed(cpd);
SWTBotShell[] shells = HSBot.bot().shells();
if (shells.length > 1) {
ProgressDialog dlgProg = new ProgressDialog("dlgTitleProgressDeleteResource");
Waits.shellClosed(dlgProg);
}
Waits.prjNotExistOnTree(name);
Waits.prjNotExistInWorkspace(name);
} else {
cpd.radBtnDoNotDeleteContents().click();
cpd.btnYes().click();
Waits.shellClosed(cpd);
SWTBotShell[] shells = HSBot.bot().shells();
if (shells.length > 1) {
ProgressDialog dlgProg = new ProgressDialog("dlgTitleProgressDeleteResource");
Waits.shellClosed(dlgProg);
}
Waits.prjNotExistOnTree(name);
Waits.prjExistInWorkspace(name);
}
}
/**
* 从 Excel 文件中取删除项目数据，并赋值给相应的成员变量;
*/
public void getDataDeleteProject() {
name = data.getTextOrEmpty(ExcelData.colPrjName);
deleteContent = data.getBoolean(ExcelData.colDeleteContent);
// expectedResult = data.getExpectedResult();
}
}
| 3,570 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ExcelData.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test.basecase/src/net/heartsome/cat/ts/test/basecase/common/ExcelData.java | package net.heartsome.cat.ts.test.basecase.common;
import static org.junit.Assert.assertTrue;
import java.util.List;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.DB;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.ExpectedResult;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants.UpdateMode;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
/**
* 专门用来从 Excel 文件中读取测试数据的类，所有存放测试数据的 Excel 表都必须使用此类规定的列头。
* @author felix_lu
* @version
* @since JDK1.6
*/
public class ExcelData {
private HsRow row;
/** 用来保存创建项目测试数据的 Excel 表格中的列头文本 */
public static String colDBType = "DBType";
public static String colServer = "Server";
public static String colPort = "Port";
public static String colInstance = "Instance";
public static String colDBPath = "DBPath";
public static String colUsername = "Username";
public static String colPassword = "Password";
public static String colSaveConn = "Save Connection";
public static String colDBName = "DBName";
public static String colTMDBName = "TMDBName";
public static String colTBDBName = "TBDBName";
public static String colExpResult = "Expected Result";
public static String colConfirm = "Confirm";
public static String colFilePath = "File Path";
public static String colUpdateMode = "Update Mode";
public static String colPrjName = "Project Name";
public static String colRemark = "Remark";
public static String colClient = "Client";
public static String colCompany = "Company";
public static String colEMail = "EMail";
public static String colSrcLang = "Source Language";
public static String colTgtLang = "Target Language";
public static String colInvChar = "Invalid Character";
public static String colDeleteContent = "Delete Content";
public static String colFileType = "File Type";
public static String colFileName = "File Name";
public static String colOldName = "Old Name";
public static String colNewName = "New Name";
public static String colOverwrite = "Overwrite";
public static String colLock100Match = "Lock 100% Match";
public static String colLockContextMatch = "Lock Context Match";
public static String colCaseSensitive = "Case Sensitive";
public static String colMinPercentage = "Min Percentage";
public static String colOverwriteMode = "Overwrite Mode";
/**
* @param row
* 用以读取测试数据的 Excel 数据行对象
*/
public ExcelData(HsRow row) {
this.row = row;
}
/**
* @param colHeader
* Excel 列头文本，请用本类提供的常量
* @return 一个文本值，若不是刚好取到一个非空值，则会报错。适用于必填项 ;
*/
public String getText(String colHeader) {
return row.getOneResultOfCol(colHeader);
}
/**
* @param colHeader
* Excel 列头文本，请用本类提供的常量
* @return 一个文本值，可能为 null 或空。适用于非必填项 ;
*/
public String getTextOrNull(String colHeader) {
return row.getNullOrOneResultOfCol(colHeader);
}
/**
* @param colHeader
* Excel 列头文本，请用本类提供的常量
* @return 一个文本值，以空字符串代替 null 值。适用于非必填项 ;
*/
public String getTextOrEmpty(String colHeader) {
String str = row.getNullOrOneResultOfCol(colHeader);
return (str == null ? "" : str);
}
/**
* @param colHeader
* Excel 列头文本，请用本类提供的常量
* @return 字符串 List，不含空值 ;
*/
public List<String> getTextList(String colHeader) {
return row.getTextOfCol(colHeader);
}
/**
* @param colHeader
* Excel 列头文本，请用本类提供的常量
* @return 字符串数组，不含空值 ;
*/
public String[] getTextArray(String colHeader) {
return row.getArrayResultOfCol(colHeader);
}
/**
* @param colHeader
* Excel 列头文本，请用本类提供的常量
* @return 布尔值 ;
*/
public boolean getBoolean(String colHeader) {
return row.getBooleanResultOfCol(colHeader);
}
/**
* @return 从 Excel 中读取文字内容的预期结果，并转换为相应的枚举值供判断，若无则报错并返回 null;
*/
public ExpectedResult getExpectedResult() {
String strResult = row.getOneResultOfCol(colExpResult);
if (strResult.equals("SUCCESS")) {
return TsUIConstants.ExpectedResult.SUCCESS;
} else if (strResult.equals("DUPLICATED_NAME")) {
return TsUIConstants.ExpectedResult.DUPLICATED_NAME;
} else if (strResult.equals("INVALID_NAME")) {
return TsUIConstants.ExpectedResult.INVALID_NAME;
} else if (strResult.equals("NO_FILE")) {
return TsUIConstants.ExpectedResult.NO_FILE;
} else if (strResult.equals("NO_DB")) {
return TsUIConstants.ExpectedResult.NO_DB;
} else if (strResult.equals("FILE_ERROR")) {
return TsUIConstants.ExpectedResult.FILE_ERROR;
} else if (strResult.equals("WRONG_TYPE")) {
return TsUIConstants.ExpectedResult.WRONG_TYPE;
} else if (strResult.equals("INVALID_FILE")) {
return TsUIConstants.ExpectedResult.INVALID_FILE;
} else if (strResult.equals("INVALID_PATH")) {
return TsUIConstants.ExpectedResult.INVALID_PATH;
} else if (strResult.equals("NO_SERVER")) {
return TsUIConstants.ExpectedResult.NO_SERVER;
} else if (strResult.equals("NO_PORT")) {
return TsUIConstants.ExpectedResult.NO_PORT;
} else if (strResult.equals("NO_INSTANCE")) {
return TsUIConstants.ExpectedResult.NO_INSTANCE;
} else if (strResult.equals("NO_USERNAME")) {
return TsUIConstants.ExpectedResult.NO_USERNAME;
} else if (strResult.equals("NO_PATH")) {
return TsUIConstants.ExpectedResult.NO_PATH;
} else if (strResult.equals("CONNECTION_ERROR")) {
return TsUIConstants.ExpectedResult.CONNECTION_ERROR;
} else if (strResult.equals("LONG_NAME")) {
return TsUIConstants.ExpectedResult.LONG_NAME;
} else {
assertTrue("无此预期结果：" + strResult, false);
return null;
}
}
/**
* @return 从 Excle 文件中读取的数据库更新模式;
*/
public UpdateMode getUpdateMode() {
String strResult = row.getOneResultOfCol(colUpdateMode);
if (strResult.equals("ALWAYS_ADD")) {
return TsUIConstants.UpdateMode.ALWAYS_ADD;
} else if (strResult.equals("OVERWRITE")) {
return TsUIConstants.UpdateMode.OVERWRITE;
} else if (strResult.equals("IGNORE")) {
return TsUIConstants.UpdateMode.IGNORE;
} else if (strResult.equals("MERGE")) {
return TsUIConstants.UpdateMode.MERGE;
} else {
assertTrue("参数错误，无此更新模式：" + strResult, false);
return null;
}
}
/**
* @return 从 Excel 文件中读取到的数据库类型，转为常量;
*/
public DB getDBType() {
String strType = row.getOneResultOfCol(colDBType);
if (strType.equals("INTERNAL")) {
return TsUIConstants.DB.INTERNAL;
} else if (strType.equals("MYSQL")) {
return TsUIConstants.DB.MYSQL;
} else if (strType.equals("ORACLE")) {
return TsUIConstants.DB.ORACLE;
} else if (strType.equals("POSTGRESQL")) {
return TsUIConstants.DB.POSTGRESQL;
} else if (strType.equals("MSSQL")) {
return TsUIConstants.DB.MSSQL;
} else {
assertTrue("无此数据库类型：" + strType, false);
return null;
}
}
/**
* @return 从 Excel 中读取的覆盖模式/策略;
*/
public UpdateMode getOverwriteMode() {
String strResult = row.getOneResultOfCol(colOverwriteMode);
if (strResult.equals("KEEP_CURRENT")) {
return TsUIConstants.UpdateMode.KEEP_CURRENT;
} else if (strResult.equals("OVERWRITE_IF_HIGHER")) {
return TsUIConstants.UpdateMode.OVERWRITE_IF_HIGHER;
} else if (strResult.equals("ALWAYS_OVERWRITE")) {
return TsUIConstants.UpdateMode.OVERWRITE;
} else {
assertTrue("无此覆盖模式：" + strResult, false);
return null;
}
}
}
| 7,968 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
AllTests.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/AllTests.java | package net.heartsome.cat.ts.test;
import junit.framework.TestSuite;
import net.heartsome.cat.ts.test.menu.db.DatabaseTest;
import net.heartsome.cat.ts.test.menu.db.ImportToDBTest;
import net.heartsome.cat.ts.test.menu.db.MemoryDatabaseTest;
import net.heartsome.cat.ts.test.menu.file.ProjectOperationTest;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
/**
* 包含 HSCAT8 TS 所有测试用例的测试套件。
* @author felix_lu
* @version
* @since JDK1.6
*/
@RunWith(Suite.class)
@SuiteClasses({
// ProjectOperationTest.class,
// DatabaseTest.class,
MemoryDatabaseTest.class,
ImportToDBTest.class })
public class AllTests extends TestSuite {
}
| 724 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
TSTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/TSTest.java | package net.heartsome.cat.ts.test;
import static org.junit.Assert.assertTrue;
import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
public class TSTest {
private static SWTWorkbenchBot bot;
@BeforeClass
public static void setup() {
bot = new SWTWorkbenchBot();
}
@Test
public void FirstTest() {
bot.menu("File").isVisible();
}
@Ignore
@Test
public void SecondTest() {
assertTrue(false);
}
@Test
public void ThirdTest() {
assertTrue(true);
}
}
| 559 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
PreTranslationTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/menu/translation/PreTranslationTest.java | package net.heartsome.cat.ts.test.menu.translation;
import java.io.FileNotFoundException;
import java.io.IOException;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import net.heartsome.test.swtbot.junit.Repeat;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.utilities.common.FileUtil;
import net.heartsome.test.utilities.poi.ExcelUtil;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet;
import net.heartsome.test.utilities.sikuli.OsUtil;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class PreTranslationTest {
private static HsSheet shPreTransData;
@BeforeClass
public static void start() throws FileNotFoundException, IOException {
String filePrjData = FileUtil.getExecutionPath() + "/testData/PreTranslationTest.xls";
shPreTransData = new ExcelUtil(filePrjData).new HsSheet("Create");
}
@AfterClass
public static void end() {
}
@Before
public void setUp() {
}
@After
public void tearDown() {
OsUtil.typeEsc();
OsUtil.typeEsc();
HSBot.bot().sleep(500);
}
// @Repeat(3)
@Test
public void tc1DeleteProject() {
}
// @Ignore
// @Repeat(5)
@Test
public void tc2CreateProject() {
}
// @Ignore
// @Repeat(5)
@Test
public void tc3RenameProject() {
}
}
| 1,448 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
DatabaseTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/menu/db/DatabaseTest.java | package net.heartsome.cat.ts.test.menu.db;
import java.io.FileNotFoundException;
import java.io.IOException;
import net.heartsome.cat.ts.test.basecase.menu.db.DBManagement;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import net.heartsome.test.swtbot.junit.Repeat;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.utilities.common.FileUtil;
import net.heartsome.test.utilities.poi.ExcelUtil;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import net.heartsome.test.utilities.sikuli.OsUtil;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class DatabaseTest {
private static HsSheet shConnectServerData;
private static HsSheet shCreateDBData;
private static HsSheet shDeleteDBData;
private int connectServerNum = 1;
private int createDBNum = 1;
private int deleteDBNum = 1;
private int deleteConnectionNum = 1;
@BeforeClass
public static void start() throws FileNotFoundException, IOException {
String filePrjData = FileUtil.getExecutionPath() + "/testData/DatabaseTest.xls";
shConnectServerData = new ExcelUtil(filePrjData).new HsSheet("Connect");
shCreateDBData = new ExcelUtil(filePrjData).new HsSheet("Create");
shDeleteDBData = new ExcelUtil(filePrjData).new HsSheet("Delete");
}
@AfterClass
public static void end() {
}
@Before
public void setUp() {
}
@After
public void tearDown() {
OsUtil.typeEsc();
OsUtil.typeEsc();
HSBot.bot().sleep(500);
}
@Repeat(23)
@Test
public void tc1ConnectServer() {
HsRow row = shConnectServerData.new HsRow(connectServerNum);
DBManagement db = new DBManagement(row);
db.connectServer(TsUIConstants.Entry.SHORTCUT);
connectServerNum++;
}
@Repeat(25)
@Test
public void tc2CreateDB() {
HsRow row = shCreateDBData.new HsRow(createDBNum);
DBManagement db = new DBManagement(row);
db.createDB(TsUIConstants.Entry.MENU);
createDBNum++;
}
@Repeat(15)
@Test
public void tc3DeleteDB() {
HsRow row = shDeleteDBData.new HsRow(deleteDBNum);
DBManagement db = new DBManagement(row);
db.deleteDB(TsUIConstants.Entry.MENU);
deleteDBNum++;
}
@Repeat(5)
@Test
public void tc4DeleteConnection() {
HsRow row = shConnectServerData.new HsRow(deleteConnectionNum);
DBManagement db = new DBManagement(row);
db.deleteConnection(TsUIConstants.Entry.SHORTCUT);
deleteConnectionNum++;
}
}
| 2,626 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
MemoryDatabaseTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/menu/db/MemoryDatabaseTest.java | package net.heartsome.cat.ts.test.menu.db;
import java.io.FileNotFoundException;
import java.io.IOException;
import net.heartsome.cat.ts.test.basecase.menu.db.MemoryDBManagement;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import net.heartsome.test.swtbot.junit.Repeat;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.utilities.common.FileUtil;
import net.heartsome.test.utilities.poi.ExcelUtil;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import net.heartsome.test.utilities.sikuli.OsUtil;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class MemoryDatabaseTest {
private static HsSheet shConnectServerData;
private static HsSheet shCreateDBData;
private static HsSheet shDeleteDBData;
private int connectServerNum = 1;
private int createDBNum = 1;
private int deleteDBNum = 1;
private int deleteConnectionNum = 1;
private int saveServerNum = 1;
@BeforeClass
public static void start() throws FileNotFoundException, IOException {
String filePrjData = FileUtil.getExecutionPath() + "/testData/DatabaseTest.xls";
shConnectServerData = new ExcelUtil(filePrjData).new HsSheet("Connect");
shCreateDBData = new ExcelUtil(filePrjData).new HsSheet("Create");
shDeleteDBData = new ExcelUtil(filePrjData).new HsSheet("Delete");
}
@AfterClass
public static void end() {
}
@Before
public void setUp() {
}
@After
public void tearDown() {
OsUtil.typeEsc();
OsUtil.typeEsc();
HSBot.bot().sleep(500);
}
// @Repeat(23)
// @Ignore
// @Test
// public void tc1ConnectServer() {
// HsRow row = shConnectServerData.new HsRow(connectServerNum);
// MemoryDBManagement db = new MemoryDBManagement(row);
// db.connectServer(TsUIConstants.Entry.MENU);
// connectServerNum++;
// }
//
// @Repeat(5)
// @Test
// public void tc12CreateServer() {
// HsRow row = shConnectServerData.new HsRow(saveServerNum);
// MemoryDBManagement db = new MemoryDBManagement(row);
// db.saveServer(TsUIConstants.Entry.MENU);
// System.out.println(saveServerNum);
// saveServerNum ++;
// }
//
//
//
// @Repeat(5)
// @Test
// public void tc2CreateDB() {
// HsRow row = shCreateDBData.new HsRow(createDBNum);
// MemoryDBManagement db = new MemoryDBManagement(row);
// db.createDB(TsUIConstants.Entry.MENU);
// createDBNum++;
// }
//
// @Repeat(15)
// @Ignore
// @Test
// public void tc3DeleteDB() {
// HsRow row = shDeleteDBData.new HsRow(deleteDBNum);
// MemoryDBManagement db = new MemoryDBManagement(row);
// db.deleteDB(TsUIConstants.Entry.MENU);
// deleteDBNum++;
// }
//
// @Repeat(5)
// @Ignore
// @Test
// public void tc4DeleteConnection() {
// HsRow row = shConnectServerData.new HsRow(deleteConnectionNum);
// MemoryDBManagement db = new MemoryDBManagement(row);
// db.deleteConnection(TsUIConstants.Entry.MENU);
// deleteConnectionNum++;
// }
@Repeat(23)
@Ignore
@Test
public void tc5ConnecttreiTbServer() {
HsRow row = shConnectServerData.new HsRow(connectServerNum);
MemoryDBManagement db = new MemoryDBManagement(row);
db.setMemory(false);
db.connectServer(TsUIConstants.Entry.MENU);
connectServerNum++;
}
@Repeat(5)
@Test
public void tc6CreatetreiTbServer() {
HsRow row = shConnectServerData.new HsRow(saveServerNum);
MemoryDBManagement db = new MemoryDBManagement(row);
db.setMemory(false);
db.saveServer(TsUIConstants.Entry.MENU);
System.out.println(saveServerNum);
saveServerNum ++;
}
@Repeat(5)
@Test
public void tc7CreatetreiTbDB() {
HsRow row = shCreateDBData.new HsRow(createDBNum);
MemoryDBManagement db = new MemoryDBManagement(row);
db.setMemory(false);
db.createDB(TsUIConstants.Entry.MENU);
createDBNum++;
}
@Repeat(15)
@Ignore
@Test
public void tc8DeletetreiTbDB() {
HsRow row = shDeleteDBData.new HsRow(deleteDBNum);
MemoryDBManagement db = new MemoryDBManagement(row);
db.setMemory(false);
db.deleteDB(TsUIConstants.Entry.MENU);
deleteDBNum++;
}
@Repeat(5)
@Ignore
@Test
public void tc9DeletetreiTbConnection() {
HsRow row = shConnectServerData.new HsRow(deleteConnectionNum);
MemoryDBManagement db = new MemoryDBManagement(row);
db.setMemory(false);
db.deleteConnection(TsUIConstants.Entry.MENU);
deleteConnectionNum++;
}
}
| 4,537 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ImportToDBTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/menu/db/ImportToDBTest.java | package net.heartsome.cat.ts.test.menu.db;
import java.io.FileNotFoundException;
import java.io.IOException;
import net.heartsome.cat.ts.test.basecase.menu.db.DBManagement;
import net.heartsome.cat.ts.test.basecase.menu.db.ImportToDB;
import net.heartsome.cat.ts.test.basecase.menu.db.MemoryDBManagement;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import net.heartsome.test.swtbot.junit.Repeat;
import net.heartsome.test.utilities.common.FileUtil;
import net.heartsome.test.utilities.poi.ExcelUtil;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsRow;
import org.eclipse.swtbot.mockdialogs.factory.NativeDialogFactory;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class ImportToDBTest {
private static HsSheet shImportTMXData;
private static HsSheet shImportTBXData;
private int importTMXNum = 1;
private int importTBXNum = 1;
@BeforeClass
public static void start() throws FileNotFoundException, IOException {
NativeDialogFactory.setMode(NativeDialogFactory.OperationMode.TESTING);
String filePrjData = FileUtil.getExecutionPath() + "/testData/ImportToDBTestSZ.xls";
shImportTMXData = new ExcelUtil(filePrjData).new HsSheet("ImportTMX");
shImportTBXData = new ExcelUtil(filePrjData).new HsSheet("ImportTBX");
// 创建导入所需的数据库
// HsRow dbRow = shImportTMXData.new HsRow(1);
// MemoryDBManagement db = new MemoryDBManagement(dbRow);
// db.createDB(TsUIConstants.Entry.MENU);
}
@AfterClass
public static void end() {
// 删除用完的数据库
HsRow dbRow = shImportTMXData.new HsRow(1);
MemoryDBManagement db = new MemoryDBManagement(dbRow);
db.deleteDB(TsUIConstants.Entry.MENU, true);
}
@Before
public void setUp() {
// TsTasks.closeDialogs();
// TsTasks.closeDialogs();
}
@After
public void tearDown() {
// OsUtil.typeEsc();
// OsUtil.typeEsc();
// HSBot.bot().sleep(500);
}
// @Repeat(10)
// @Test
// public void tc1ImportTMX() {
// HsRow row = shImportTMXData.new HsRow(importTMXNum);
// ImportToDB tmx = new ImportToDB(TsUIConstants.ImportType.TMX, row);
// tmx.importTMX(TsUIConstants.Entry.MENU);
// importTMXNum++;
// }
@Repeat(10)
@Test
public void tc2ImportTBX() {
HsRow row = shImportTBXData.new HsRow(importTBXNum);
ImportToDB tbx = new ImportToDB(TsUIConstants.ImportType.TBX, row);
tbx.importTBX(TsUIConstants.Entry.MENU);
importTBXNum++;
}
}
| 2,662 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ProjectOperationTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/menu/file/ProjectOperationTest.java | package net.heartsome.cat.ts.test.menu.file;
import java.io.FileNotFoundException;
import java.io.IOException;
import net.heartsome.cat.ts.test.basecase.menu.file.ProjectCreate;
import net.heartsome.cat.ts.test.basecase.menu.file.ProjectDelete;
import net.heartsome.cat.ts.test.basecase.menu.file.ProjectRename;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import net.heartsome.test.swtbot.junit.Repeat;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.utilities.common.FileUtil;
import net.heartsome.test.utilities.poi.ExcelUtil;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet;
import net.heartsome.test.utilities.sikuli.OsUtil;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class ProjectOperationTest {
private static HsSheet shCreatePrjData;
private static HsSheet shRenamePrjData;
private static HsSheet shDeletePrjData;
private int createPrjNum = 1;
private int renamePrjNum = 1;
private int deletePrjNum = 1;
@BeforeClass
public static void start() throws FileNotFoundException, IOException {
String filePrjData = FileUtil.getExecutionPath() + "/testData/ProjectOperationTest.xls";
shCreatePrjData = new ExcelUtil(filePrjData).new HsSheet("Create");
shRenamePrjData = new ExcelUtil(filePrjData).new HsSheet("Rename");
shDeletePrjData = new ExcelUtil(filePrjData).new HsSheet("Delete");
}
@AfterClass
public static void end() {
}
@Before
public void setUp() {
// ProjectTreeView.getInstance().ctxMenuRefresh().click();
}
@After
public void tearDown() {
OsUtil.typeEsc();
OsUtil.typeEsc();
HSBot.bot().sleep(500);
}
@Repeat(3)
@Test
public void tc1DeleteProject() {
ProjectCreate prj1 = new ProjectCreate(shCreatePrjData.new HsRow(deletePrjNum));
prj1.createPrj(TsUIConstants.Entry.MENU);
ProjectDelete prj2 = new ProjectDelete(shDeletePrjData.new HsRow(deletePrjNum));
prj2.deletePrj(TsUIConstants.Entry.MENU);
deletePrjNum++;
}
// @Ignore
@Repeat(5)
@Test
public void tc2CreateProject() {
ProjectCreate prj = new ProjectCreate(shCreatePrjData.new HsRow(createPrjNum));
prj.createPrj(TsUIConstants.Entry.MENU);
createPrjNum++;
}
// @Ignore
@Repeat(5)
@Test
public void tc3RenameProject() {
ProjectRename prj = new ProjectRename(shRenamePrjData.new HsRow(renamePrjNum));
prj.renamePrj(TsUIConstants.Entry.SHORTCUT);
renamePrjNum++;
}
}
| 2,650 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
CustomFilter.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/basecase/CustomFilter.java | package net.heartsome.cat.ts.test.basecase;
import net.heartsome.cat.ts.test.ui.dialogs.ManageCustomFilterDialog;
import net.heartsome.cat.ts.test.ui.editors.XlfEditor;
import net.heartsome.cat.ts.test.ui.tasks.Waits;
/**
* 自定义过滤器相关操作
* @author felix_lu
*
*/
public class CustomFilter {
private XlfEditor xe;
private ManageCustomFilterDialog mcfd;
public CustomFilter(XlfEditor xe) {
this.xe = xe;
}
public void addFilter(String filterName, String matchAndOr, String[]... conditions) {
}
public void openDialog() {
xe.btnAddCustomFilter().click();
mcfd = new ManageCustomFilterDialog();
mcfd.isActive();
}
public void closeDialog() {
mcfd = new ManageCustomFilterDialog();
mcfd.btnClose().click();
Waits.shellClosed(mcfd);
}
public void saveFilter(String isValid) {
}
public void addFilter_Name(String filterName, String isValid) {
}
public void addCondition_Keyword(String matchType, String keywordValue, boolean isValid) {
}
public void addCondition_State(String matchType, String stateValue, boolean isValid) {
}
public void addCondition_Note(String matchType, String noteValue, boolean isValid) {
}
public void addCondition_Prop(String propName, String propValue, boolean isValid) {
}
}
| 1,293 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
SplitSegment.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/basecase/SplitSegment.java | package net.heartsome.cat.ts.test.basecase;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.editors.XlfEditor;
import net.heartsome.cat.ts.test.ui.msgdialogs.InformationDialog;
import net.heartsome.cat.ts.test.ui.tasks.SegmentAsserts;
import net.heartsome.cat.ts.test.ui.utils.XliffUtil;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.swtbot.widgets.SWTBotNatTable;
import net.heartsome.test.swtbot.widgets.HsSWTBotStyledText;
import net.heartsome.test.utilities.common.StringUtil;
import org.eclipse.swtbot.swt.finder.utils.Position;
/**
* 分割文本段的常用方法
* @author felix_lu
*
*/
public class SplitSegment {
static TS ts = TS.getInstance();
/**
* 在指定文本段的 index 处分割文本段
* @param xe
* @param segNum
* @param splitIndex
*/
public static void splitAt(XlfEditor xe, int segNum, int splitIndex) {
// 判断该文本段是否可编辑
String rowID = xe.rowIdOfSegNum(segNum);
XliffUtil xu = new XliffUtil(rowID);
SegmentAsserts.segIsEditable(xu);
// 进入编辑模式，方便读取样式文本框中的内容
xe.enterEditModeSource(segNum);
// 在实际进行分割文本段之前，得到原文本段的 tuid 和分割后两个文本段的预期内容，
// 用以在分割后验证得到的文本段内容是否符合预期。
String tuid = xe.tuidOfSegNum(segNum);
// 判断给定的分割点是否可分割，然后在两个分支中分别验证结果
HsSWTBotStyledText st = xe.getStyledText();
if (SegmentAsserts.indexIsSplitable(st, splitIndex)) {
String[] expectedText = st.splitTextAt(splitIndex);
// 将光标移到指定位置，并点击相应的菜单项进行分割
xe.navigateToIndex(splitIndex);
ts.menuTranslationSplitSegment().click();
xe.getNatTable();
// 确认文本段已按预期分割
SegmentAsserts.segIsSplit(tuid, expectedText, xe.getSplitXliffUtil(expectedText));
System.out.println("[Passed] Segment No.\"" + segNum + "\" was successfully split at Index \"" + splitIndex + "\".");
}
else {
String expectedText = st.getText();
String position;
// 将光标移到指定位置，并点击相应的菜单项进行分割
if (splitIndex <= 0) {
position = "Beginning.";
xe.navigateToBegining();
}
else {
position = "End.";
xe.navigateToEnd();
}
ts.menuTranslationSplitSegment().click();
// 弹出提示信息
InformationDialog dialog = new InformationDialog(1,
TsUIConstants.getString("msgPlaceCursorToSplit"));
dialog.lblMessage().isVisible();
dialog.btnOK().click();
xe.getNatTable();
// 确认文本段没有被分割
SegmentAsserts.segNotSplit(tuid, expectedText, xu);
System.out.println("[Passed] Segment No.\"" + segNum + "\" was not split at the " + position);
}
}
/**
* @param xe 要操作的 XlfEditor 对象
* @param segNum 要分割的文本段序号
* @param afterText 在此文本之后分割
*/
public static void splitAfter(XlfEditor xe, int segNum, String afterText) {
SWTBotNatTable nt = xe.getNatTable();
xe.selectSourceCell(segNum);
Position pos = nt.positionOfSelectedCell();
String expectedText = nt.getTextByPosition(pos.line, pos.column);
int splitIndex = StringUtil.indexAfterWithAssert(expectedText, afterText);
splitAt(xe, segNum, splitIndex);
}
/**
* @param xe 要操作的 XlfEditor 对象
* @param segSourceText 要分割的文本段源文本内容
* @param afterText 在此文本之后分割
*/
public static void splitAfter(XlfEditor xe, String segSourceText, String afterText) {
int segNum = xe.segNumOfSource(segSourceText);
splitAfter(xe, segNum, afterText);
}
/**
* @param xe 要操作的 XlfEditor 对象
* @param segNum 要分割的文本段序号
* @param beforeText 在此文本之前分割
*/
public static void splitBefore(XlfEditor xe, int segNum, String beforeText) {
SWTBotNatTable nt = xe.getNatTable();
xe.selectSourceCell(segNum);
Position pos = nt.positionOfSelectedCell();
String expectedText = nt.getTextByPosition(pos.line, pos.column);
int splitIndex = StringUtil.indexBeforeWithAssert(expectedText, beforeText);
splitAt(xe, segNum, splitIndex);
}
/**
* @param xe 要操作的 XlfEditor 对象
* @param segSourceText 要分割的文本段源文本内容
* @param beforeText 在此文本之前分割
*/
public static void splitBefore(XlfEditor xe, String segSourceText, String beforeText) {
int segNum = xe.segNumOfSource(segSourceText);
splitBefore(xe, segNum, beforeText);
}
/**
* @param xe 要操作的 XlfEditor 对象
* @param segNum 要分割的文本段序号
* @param afterText 在此文本之后分割，此内容在文本段中必须与下一个参数相邻
* @param beforeText 在此文本之前分割，此内容在文本段中必须与上一个参数相邻
*/
public static void splitBetween(XlfEditor xe, int segNum, String afterText, String beforeText) {
SWTBotNatTable nt = xe.getNatTable();
xe.selectSourceCell(segNum);
Position pos = nt.positionOfSelectedCell();
String expectedText = nt.getTextByPosition(pos.line, pos.column);
int splitIndex = StringUtil.indexBetweenWithAssert(expectedText, afterText, beforeText);
splitAt(xe, segNum, splitIndex);
}
/**
* @param xe 要操作的 XlfEditor 对象
* @param segSourceText 要分割的文本段源文本内容
* @param afterText 在此文本之后分割，此内容在文本段中必须与下一个参数相邻
* @param beforeText 在此文本之前分割，此内容在文本段中必须与上一个参数相邻
*/
public static void splitBetween(XlfEditor xe, String segSourceText, String afterText, String beforeText) {
int segNum = xe.segNumOfSource(segSourceText);
splitBetween(xe, segNum, afterText, beforeText);
}
/**
* 尝试从段首分割文本段
* @param xe 要操作的 XlfEditor 对象
* @param segNum 尝试分割的文本段序号
*/
public static void splitAtBeginning(XlfEditor xe, int segNum) {
splitAt(xe, segNum, 0);
}
/**
* 尝试从段末分割文本段
* @param xe 要操作的 XlfEditor 对象
* @param segNum 尝试分割的文本段序号
*/
public static void splitAtEnd(XlfEditor xe, int segNum) {
SWTBotNatTable nt = xe.getNatTable();
xe.selectSourceCell(segNum);
Position pos = nt.positionOfSelectedCell();
String expectedText = nt.getTextByPosition(pos.line, pos.column);
int splitIndex = expectedText.length();
splitAt(xe, segNum, splitIndex);
}
/**
* 尝试不将光标置于源文本中直接分割
* @param xe 要操作的 XlfEditor 对象
* @param segNum 尝试分割的文本段序号
*/
public static void splitWithoutCursor(XlfEditor xe, int segNum) {
// 判断该文本段是否可编辑
String rowID = xe.rowIdOfSegNum(segNum);
XliffUtil xu = new XliffUtil(rowID);
SegmentAsserts.segIsEditable(xu);
// 选中文本段的源文本单元格，而不进入编辑状态
xe.selectSourceCell(segNum);
// 在实际进行分割文本段之前，得到原文本段的 tuid，用以验证得到的文本段内容是否符合预期。
String tuid = xe.tuidOfSegNum(segNum);
// 判断给定的分割点是否可分割
SWTBotNatTable nt = xe.getNatTable();
Position pos = nt.positionOfSelectedCell();
String expectedText = nt.getTextByPosition(pos.line, pos.column);
// 点击相应的菜单项进行分割
ts.menuTranslationSplitSegment().click();
// 弹出提示信息
InformationDialog dialog = new InformationDialog(1,
TsUIConstants.getString("msgPlaceCursorToSplit"));
dialog.lblMessage().isVisible();
dialog.btnOK().click();
xe.getNatTable();
// 确认文本段没有被分割
SegmentAsserts.segNotSplit(tuid, expectedText, xu);
}
/**
* 尝试分割已批准的文本段
* @param xe 要操作的 XlfEditor 对象
* @param segNum 尝试分割的文本段序号
*/
public static void splitApprovedSeg(XlfEditor xe, int segNum) {
// 判断该文本段是否已批准
String rowID = xe.rowIdOfSegNum(segNum);
XliffUtil xu = new XliffUtil(rowID);
assertTrue(xu.tuIsApproved());
// 进入编辑模式，方便读取样式文本框中的内容
xe.enterEditModeSource(segNum);
// 在实际进行分割文本段之前，得到原文本段的 tuid 和分割后两个文本段的预期内容，
// 用以在分割后验证得到的文本段内容是否符合预期。
String tuid = xe.tuidOfSegNum(segNum);
// 判断给定的分割点是否可分割
HsSWTBotStyledText st = xe.getStyledText();
String expectedText = st.getText();
// 将光标移到任意位置（这里取 index=1），并点击相应的菜单项进行分割
xe.navigateToIndex(1);
ts.menuTranslationSplitSegment().click();
// 弹出提示信息
InformationDialog dialog = new InformationDialog(1,
TsUIConstants.getString("msgCannotMergeApprovedSeg"));
dialog.lblMessage().isVisible();
dialog.btnOK().click();
xe.getNatTable();
// 确认文本段没有被分割
SegmentAsserts.segNotSplit(tuid, expectedText, xu);
}
/**
* 尝试分割已锁定的文本段
* @param xe 要操作的 XlfEditor 对象
* @param segNum 尝试分割的文本段序号
*/
public static void splitUntranslatableSeg(XlfEditor xe, int segNum) {
// TODO 根据 R8 的实现，可考虑与上一个方法合并，否则还需要单独考虑“已批准且已锁定”文本段的情况
}
/**
* 未打开文件时，分割文本段功能被禁用
*/
public static void splitWithoutFile() {
assertTrue(HSBot.bot().editors().isEmpty());
assertTrue(!ts.menuTranslationSplitSegment().isEnabled());
}
}
| 9,847 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
MergeSegments.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/basecase/MergeSegments.java | package net.heartsome.cat.ts.test.basecase;
import static org.junit.Assert.assertTrue;
import net.heartsome.cat.ts.test.ui.constants.TsUIConstants;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.editors.XlfEditor;
import net.heartsome.cat.ts.test.ui.msgdialogs.InformationDialog;
import net.heartsome.cat.ts.test.ui.tasks.SegmentAsserts;
import net.heartsome.cat.ts.test.ui.utils.XliffUtil;
/**
* 合并文本段的常用方法
* @author felix_lu
*
*/
public class MergeSegments {
static TS ts = TS.getInstance();
/**
* 合并两个文本段，仅适合能取到要合并的两个文本段序号的情况
* @param xe 要操作的 XliffEditor 对象
* @param segNum 由要合并的两个文本段序号组成的 int 数组
* @param direction 合并方向：N 表示 Next，即与下一文本段合并；P 表示 Previous，即与上一文本段合并
*/
public static void MergeSegs(XlfEditor xe, int[] segNum, String direction) {
// 先判断传入的方向参数是否正确
assertTrue("Wrong value for parameter \"direction\".", "N".equals(direction) || "P".equals(direction));
String[] rowID = new String[2];
XliffUtil[] xu = new XliffUtil[2];
String[] tuid = new String[2];
String[] srcText = new String[2];
for (int i = 0; i < 2; i++) {
rowID[i] = xe.rowIdOfSegNum(segNum[i]);
xu[i] = new XliffUtil(rowID[i]);
tuid[i] = xu[i].getTUID();
srcText[i] = xu[i].getSourceText();
}
// 判断两个文本段符合合并文本段的条件
if (SegmentAsserts.segsAreMergeable(xe, xu[0], xu[1])) {
// 预先得到合并后的源文本内容
String tag = "<ph id=\"hs-merge" + tuid[0] + "~" + tuid[1] + "\"/>";
String expectedText = srcText[0] + tag + srcText[1];
// 跳到指定文本段，执行合并操作
// 方向为与下一文本段合并
if (direction.equals("N")) {
xe.gotoSeg(segNum[0]);
// ts.menuTranslationMergeWithNextSegment().click(); // FIXME
}
// 方向为与上一文本段合并
else {
xe.gotoSeg(segNum[1]);
// ts.menuTranslationMergeWithPreivousSegment().click(); // FIXME
}
// 更新 NatTable
xe.getNatTable();
// 更新 XliffUtil
for (int i = 0; i < 2; i++) {
xu[i] = new XliffUtil(rowID[i]);
}
// 断言指定的两个文本段已经成功合并
SegmentAsserts.segsAreMerged(xu, tuid, expectedText);
}
// 不符合合并条件
else {
// 跳到指定文本段，尝试执行合并操作
TryMergeAndVerifyMsg(xe, xu[0], xu[1], segNum[0], segNum[1], direction);
// 更新 NatTable
xe.getNatTable();
// 更新 XliffUtil
for (int i = 0; i < 2; i++) {
xu[i] = new XliffUtil(rowID[i]);
}
// 断言指定的两个文本段没有被合并
SegmentAsserts.segsNotMerged(xu, tuid, srcText);
}
}
/**
* 指定两个文本段，由第一个文本段与第二个文本段合并
* @param xe 要操作的 XlfEditor 对象
* @param segNum 由要合并的两个文本段序号组成的 int 数组
*/
public static void MergeWithNextSeg(XlfEditor xe, int[] segNum) {
MergeSegs(xe, segNum, "N");
}
/**
* 指定两个文本段，由第二个文本段与第一个文本段合并
* @param xe 要操作的 XlfEditor 对象
* @param segNum 由要合并的两个文本段序号组成的 int 数组
*/
public static void MergeWithPrevSeg(XlfEditor xe, int[] segNum) {
MergeSegs(xe, segNum, "P");
}
/**
* 尝试将最后一个文本段与下一个文本段合并
* @param xe XlfEditor 编辑器
* @param segNum 文本段序号
*/
public static void MergeWithNoNext(XlfEditor xe, int segNum) {
MergeWithNoPartner(xe, segNum, "N");
}
/**
* 尝试将第一个文本段与上一个文本段合并
* @param xe XlfEditor 编辑器
* @param segNum 文本段序号
*/
public static void MergeWithNoPrev(XlfEditor xe, int segNum) {
MergeWithNoPartner(xe, segNum, "P");
}
/**
* 尝试将文本段与不存在的上/下一个文本段合并
* @param xe 编辑器
* @param segNum 文本段序号
* @param direction 合并方向，只能为 N 或 P
*/
private static void MergeWithNoPartner(XlfEditor xe, int segNum, String direction) {
assertTrue("Wrong value for parameter \"direction\".", "N".equals(direction) || "P".equals(direction));
String rowID = xe.rowIdOfSegNum(segNum);
XliffUtil xu = new XliffUtil(rowID);
String tuid = xu.getTUID();
String srcText = xu.getSourceText();
if ("N".equals(direction)) {
TryMergeAndVerifyMsg(xe, xu, null, segNum, 0, "N");
}
else {
TryMergeAndVerifyMsg(xe, null, xu, 0, segNum, "P");
}
// 更新 NatTable
xe.getNatTable();
// 更新 XliffUtil
xu = new XliffUtil(rowID);
// 断言文本段没有被改动
SegmentAsserts.segNoChange(xu, tuid, srcText);
}
/**
* 尝试合并不可合并的文本段，并验证出现的信息对话框
* @param xe 编辑器
* @param xu1 第一个（即欲与下一个文本段合并的）文本段 XliffUtil 对象
* @param xu2 第二个（即欲与上一个文本段合并的）文本段 XliffUtil 对象
* @param segNum1 第一个文本段序号
* @param segNum2 第二个文本段序号
* @param direction 合并方向，只允许为 N 或 P
*/
private static void TryMergeAndVerifyMsg(XlfEditor xe, XliffUtil xu1, XliffUtil xu2,
int segNum1, int segNum2, String direction) {
// 先判断传入的方向参数是否正确
assertTrue("Wrong value for parameter \"direction\".", "N".equals(direction) || "P".equals(direction));
// 方向为与下一文本段合并
if ("N".equals(direction)) {
xe.gotoSeg(segNum1);
// ts.menuTranslationMergeWithNextSegment().click(); // FIXME
// 若未找到下一个非空文本段，则验证弹出的信息对话框
if (xu1.getNextNotNullXU() == null) {
InformationDialog cnms = new InformationDialog(1,
TsUIConstants.getString("msgCannotMergeSegWhenNoNextSeg"));
cnms.lblMessage().isVisible();
cnms.btnOK().click();
}
}
// 方向为与上一文本段合并
else {
xe.gotoSeg(segNum2);
// ts.menuTranslationMergeWithPreivousSegment().click(); // FIXME
// 若未找到上一个非空文本段，则验证弹出的信息对话框
if (xu2.getPrevNotNullXU() == null) {
InformationDialog cnms = new InformationDialog(1,
TsUIConstants.getString("msgCannotMergeSegWhenNoPrevSeg"));
cnms.lblMessage().isVisible();
cnms.btnOK().click();
}
}
// 若两个文本段中任一个为已批准，则验证弹出的信息对话框
if (xu1.tuIsApproved() || xu2.tuIsApproved()) {
InformationDialog cnmas = new InformationDialog(1,
TsUIConstants.getString("msgCannotMergeApprovedSeg"));
cnmas.lblMessage().isVisible();
cnmas.btnOK().click();
}
// TODO 根据具体的实现决定是否需要增加更多信息对话框相关判断，比如尝试合并锁定文本段时
}
}
| 6,977 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
SplitSegmentTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/demos/SplitSegmentTest.java | package net.heartsome.cat.ts.test.demos;
import net.heartsome.cat.ts.test.basecase.SplitSegment;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.editors.XlfEditor;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.utilities.common.FileUtil;
import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class SplitSegmentTest {
SWTWorkbenchBot bot;
TS ts;
String prjName;
String fileName;
XlfEditor xe;
int segNum;
char INVISIBLE_CHAR;
String reTag;
/**
* 所有测试开始之前执行
*/
@BeforeClass
public static void oneTimeSetUp() {
}
/**
* 所有测试完成之后执行
*/
@AfterClass
public static void oneTimeTearDown() {
}
/**
* 每个测试开始之前执行
*/
@Before
public void setUp() {
// SWTBotPreferences.PLAYBACK_DELAY = 500;
SWTBotPreferences.KEYBOARD_LAYOUT = "EN_US";
INVISIBLE_CHAR = XlfEditor.INVISIBLE_CHAR;
reTag = "(" + INVISIBLE_CHAR + "\\d+)?" + INVISIBLE_CHAR + "(x|bx|ex|g|bpt|ept|mrk|sub|ph|it)" + INVISIBLE_CHAR + "(\\d+" + INVISIBLE_CHAR + ")?";
bot = HSBot.bot();
bot.closeAllEditors();
ts = TS.getInstance();
prjName = "prjBot-001";
fileName = "HSCAT8-2T.xlf";
ProjectTreeView.doubleClickXlfFile(prjName, fileName);
xe = new XlfEditor(bot.editorByTitle(fileName));
}
/**
* 每次测试完成之后执行
*/
@After
public void tearDown() {
String filePath = FileUtil.joinPath(FileUtil.getWorkspacePath(), prjName, "XLIFF", "HSCAT8-2T.xlf");
String originalFilePath = "testFiles/HSCAT8-2.xlf";
FileUtil.replaceFile(filePath, originalFilePath);
// bot.sleep(500);
}
@Ignore
@Test
public void SplitSegment1() {
String segText = "Test segment 2a.";
String afterText = "Test segment 2";
String beforeText = "a.";
segNum = xe.segNumContainsSource(segText);
SplitSegment.splitBetween(xe, segNum, afterText, beforeText);
}
@Ignore
@Test
public void SplitSegment2() {
String segText = "Test segment 3a";
segNum = xe.segNumContainsSource(segText);
SplitSegment.splitAtBeginning(xe, segNum);
}
@Ignore
@Test
public void SplitSegment3() {
String segText = "Test segment 3a";
segNum = xe.segNumContainsSource(segText);
SplitSegment.splitAtEnd(xe, segNum);
}
@Ignore
@Test
public void SplitSegment4() {
String segText = "Test segment 23";
segNum = xe.segNumContainsSource(segText);
SplitSegment.splitApprovedSeg(xe, segNum);
}
}
| 2,867 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
CursorPosition.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/demos/CursorPosition.java | package net.heartsome.cat.ts.test.demos;
import net.heartsome.test.swtbot.finders.HsSWTWorkbenchBot;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class CursorPosition {
private HsSWTWorkbenchBot bot;
@Before
public void setUp() {
// SWTBotPreferences.PLAYBACK_DELAY = 500;
SWTBotPreferences.KEYBOARD_LAYOUT = "EN_US";
bot = new HsSWTWorkbenchBot();
}
/*
@Ignore
@Test
public void SetCursorPositionInSourceCell() {
int rowPosition = 2;
int columnPosition = 1;
int inLine = 0;
int inColumn = 2;
String text = "segment";
NatTable nt = (NatTable) bot.widget(widgetOfType(NatTable.class));
SWTBotNatTable sbnt = new SWTBotNatTable(nt);
sbnt.click(rowPosition, columnPosition);
// Screen s = new Screen();
// try {
// s.type(null, "\n", 0);
// } catch (FindFailed e) {
// e.printStackTrace();
// }
System.out.println("Before " + bot.styledText().cursorPosition());
net.heartsome.test.swtbot.widgets.SWTBotStyledText srcText = bot.styledText();
srcText.navigateTo(inLine, inColumn);
System.out.println("After " + bot.styledText().cursorPosition());
int textIndex = srcText.indexOf(text);
System.out.println("Index: " + textIndex);
System.out.println("Position: " + srcText.getPositionByIndex(textIndex));
Pattern inlineElements = Pattern.compile("(\u00A0\\d+)?\u00A0(x|bx|ex|g|bpt|ept|mrk|sub|ph|it)\u00A0(\\d+\u00A0)?");
Matcher m = inlineElements.matcher(bot.styledText().getText());
int i = 0;
while (m.find()) {
int start = m.start();
int end = m.end();
System.out.println("Found " + ++i + ": " + start + " ~ " + end);
}
}*/
@Test
public void GetViews() {
System.out.println("Views: " + bot.views());
}
@After
public void tearDown() {
bot.sleep(500);
}
}
| 1,973 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
MergeSegmentsTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/demos/MergeSegmentsTest.java | package net.heartsome.cat.ts.test.demos;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import net.heartsome.cat.ts.test.basecase.MergeSegments;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.editors.XlfEditor;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import net.heartsome.test.swtbot.junit.Repeat;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.utilities.common.FileUtil;
import net.heartsome.test.utilities.poi.ExcelUtil;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet;
import net.heartsome.test.utilities.poi.ExcelUtil.HsSheet.HsColumn;
import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class MergeSegmentsTest {
SWTWorkbenchBot bot;
TS ts;
String prjName;
String fileName;
XlfEditor xe;
int segNum;
char INVISIBLE_CHAR;
String reTag;
static HsSheet hss;
static HsColumn srcTextCol1;
static HsColumn srcTextCol2;
static boolean RESTORE_TYPE_FILE = true; // 默认每次测试完成后还原测试文件
static boolean SLOW_PLAYBACK = false; // 默认用正常速度回放
/**
* 所有测试开始之前执行
* @throws IOException
* @throws FileNotFoundException
*/
@BeforeClass
public static void oneTimeSetUp() throws FileNotFoundException, IOException {
String excelPath = "testData/SegmentMerge.xls";
hss = new ExcelUtil(excelPath).new HsSheet();
srcTextCol1 = hss.new HsColumn("SourceText1");
srcTextCol2 = hss.new HsColumn("SourceText2");
}
/**
* 所有测试完成之后执行
*/
@AfterClass
public static void oneTimeTearDown() {
}
/**
* 每个测试开始之前执行
*/
@Before
public void setUp() {
if (SLOW_PLAYBACK) {
SWTBotPreferences.PLAYBACK_DELAY = 500;
}
SWTBotPreferences.KEYBOARD_LAYOUT = "EN_US";
INVISIBLE_CHAR = XlfEditor.INVISIBLE_CHAR;
reTag = "(" + INVISIBLE_CHAR + "\\d+)?" + INVISIBLE_CHAR + "(x|bx|ex|g|bpt|ept|mrk|sub|ph|it)" + INVISIBLE_CHAR + "(\\d+" + INVISIBLE_CHAR + ")?";
bot = HSBot.bot();
bot.closeAllEditors();
ts = TS.getInstance();
prjName = "swtBot-Project-001";
fileName = "HSCAT8-3.xlf";
ProjectTreeView.doubleClickXlfFile(prjName, fileName);
xe = new XlfEditor(bot.editorByTitle(fileName));
}
/**
* 每次测试完成之后执行
*/
@After
public void tearDown() {
if (RESTORE_TYPE_FILE) {
String filePath = "testFiles/HSCAT8-3.xlf";
String originalFilePath = "testFiles/HSCAT8-3a.xlf";
File file = new File(filePath);
if (file.exists()) {
file.delete();
}
File fileO = new File(originalFilePath);
try {
FileUtil.copyFile(fileO, file);
} catch (IOException e) {
e.printStackTrace();
}
}
// bot.sleep(500);
}
// @Ignore
@Repeat(5)
@Test
public void MergeSegment1() {
// String seg1Text = "Test segment 1a.";
// String seg2Text = "Test segment 1b.";
String seg1Text = srcTextCol1.getNextText();
String seg2Text = srcTextCol2.getNextText();
int[] segNum = new int[2];
segNum[0] = xe.segNumContainsSource(seg1Text);
segNum[1] = xe.segNumContainsSource(seg2Text);
MergeSegments.MergeWithNextSeg(xe, segNum);
}
@Ignore
@Test
public void MergeSegment2() {
String seg1Text = "Test segment 2a.";
String seg2Text = "Test segment 2b.";
int[] segNum = new int[2];
segNum[0] = xe.segNumContainsSource(seg1Text);
segNum[1] = xe.segNumContainsSource(seg2Text);
MergeSegments.MergeWithPrevSeg(xe, segNum);
}
@Ignore
@Test
public void MergeSegment3() {
// String segText = "Test segment 19.";
// segNum = xe.segNumContainsSource(segText);
segNum = 1;
MergeSegments.MergeWithNoPrev(xe, segNum);
}
@Ignore
@Test
public void MergeSegment4() {
// String segText = "Test segment 20, Test segment 23a, Test segment 24a.";
// segNum = xe.segNumContainsSource(segText);
segNum = xe.segCount();
MergeSegments.MergeWithNoNext(xe, segNum);
}
}
| 4,278 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
CreateProjectDemo.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/demos/CreateProjectDemo.java | package net.heartsome.cat.ts.test.demos;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
import org.eclipse.swtbot.swt.finder.SWTBotAssert;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class CreateProjectDemo {
private SWTWorkbenchBot bot;
@Before
public void setup() {
// SWTBotPreferences.PLAYBACK_DELAY = 500;
bot = new SWTWorkbenchBot();
}
@Test
public void createProject() throws Exception {
String projectName = "prjBot-001";
bot.menu("File").menu("New").click();
SWTBotShell shell = bot.shell("New");
shell.activate();
// From menu open File > New dialog, verify whether the dialog has been opened.
bot.tree().select("Project");
SWTBotAssert.assertEnabled(bot.button("Next >"));
// After selecting Project, the Next button should be enabled.
bot.button("Next >").click();
bot.textWithLabel("Project name:").setText(projectName);
SWTBotAssert.assertEnabled(bot.button("Finish"));
// Enter the Project Name, then Finish button should be enabled.
bot.button("Finish").click();
SWTBotAssert.assertVisible(bot.tree().select(projectName));
// Click Finish button and verify whether the project's been successfully created.
}
@After
public void teardown() {
bot.sleep(1000);
}
}
| 1,476 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
TestDemos.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/demos/TestDemos.java | package net.heartsome.cat.ts.test.demos;
import static org.junit.Assert.assertTrue;
import java.util.List;
import net.heartsome.cat.ts.test.ui.dialogs.OpenFileDialog;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.editors.XlfEditor;
import net.heartsome.cat.ts.test.ui.utils.XliffUtil;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeItem;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import net.heartsome.test.swtbot.utils.HSBot;
import net.heartsome.test.utilities.common.FileUtil;
import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class TestDemos {
private static SWTWorkbenchBot bot;
private static String prjName;
@BeforeClass
public static void startTest() {
if (DEBUG_MODE == 2) {
SWTBotPreferences.PLAYBACK_DELAY = 500;
}
SWTBotPreferences.KEYBOARD_LAYOUT = "EN_US";
bot = HSBot.bot();
}
@Before
public void setUp() {
bot.closeAllEditors();
prjName = "prjBot-001";
}
@After
public void tearDown() {
// bot.sleep(50000);
}
// 0 表示关闭 Debug 功能，即每次测试完成后还原测试文件，且用默认速度回放；
// 1 表示每次测试完成后不还原测试文件，且用默认速度回放；
// 2 表示每次测试完成后不还原测试文件，且用慢速回放。
private static int DEBUG_MODE = 1;
@AfterClass
public static void exitTest() {
if (DEBUG_MODE == 0) {
String filePath = FileUtil.joinPath(FileUtil.getExecutionPath() + prjName + "XLIFF" + "HSCAT8-83T.xlf");
String originalFilePath = FileUtil.joinPath(FileUtil.getExecutionPath() + prjName + "XLIFF" + "HSCAT8-83a.xlf");
FileUtil.replaceFile(filePath, originalFilePath);
}
}
@Ignore
@Test
public void TestProject() {
// String fileName = "temp.xlf";
String srcLang = "en-US";
String tgtLang = "zh-CN";
// String icon = "E:\\temp\\imgs\\LineNumber.png";
// String menuText = "设置文本段批准状态";
ProjectTreeItem pTN = ProjectTreeItem.getInstance(prjName);
pTN.ctxMenuOpenProjectFiles();
// String filePath = "D:\\Temp\\ts.win32.win32.x86\\workspace\\prjBot-001\\XLIFF\\temp.xlf";
// String fileName = new Path(filePath).lastSegment();
TS ts = TS.getInstance();
// ts.menuFileOpenFile().click();
// OpenFileDialog.openFile(filePath);
XlfEditor xe = ts.getXlfEditor(prjName);
xe.selectLangPair(srcLang, tgtLang);
xe.changeEditorLayout();
xe.selectSourceCell(4);
System.out.println(xe.rowIdOfSelectedSeg());
// String filePath = "D:\\Temp\\TestExcel.xls";
// String column = "password";
// ExcelUtil exl = new ExcelUtil(filePath);
// System.err.println(exl.getNextText(column));
// XLIFFUtil xu = new XLIFFUtil(filePath);
// System.err.println(xu.getSouceLang());
// System.err.println(xu.getTargetLang());
}
@Ignore
@Test
public void TestFile() {
String fileName = "HSCAT8-83.xlf";
ProjectTreeItem pTN = ProjectTreeItem.getInstance(prjName);
pTN.ctxMenuOpenFile(fileName);
TS ts = TS.getInstance();
XlfEditor xe = ts.getXlfEditor(fileName);
int segNum = 2;
xe.gotoSeg(segNum);
String rowID = xe.rowIdOfSegNum(segNum);
XliffUtil xu = new XliffUtil(rowID);
assertTrue(!xu.tuIsApproved());
xe.clickContextMenu(xe.ctxMenuApproveStatus(),
xe.ctxMenuapproveStatusApproveCurrentSeg());
xu = new XliffUtil(rowID);
assertTrue(xu.tuIsApproved());
}
@Ignore
@Test
public void TestFile2() {
// String filePath = "E:\\My Documents\\junit-workspace\\prjBot-001\\XLIFF\\HSCAT8-3.xlf";
// String filePath = "/home/felix/junit-workspace/prjBot-001/XLIFF/HSCAT8-3.xlf";
String filePath = "/Users/felix_lu/bin/ts.cocoa.macosx.x86_64/Eclipse.app/Contents/MacOS/workspace/testProject/XLIFF/HSCAT8-83.xlf";
TS ts = TS.getInstance();
ts.menuFileOpenFile().click();
OpenFileDialog.openFile(filePath, true, true);
List<String[]> langPairs = XliffUtil.getAllLangPairs(filePath);
for (String[] langPair : langPairs) {
System.err.println(langPair[0] + " -> " + langPair[1] + ": " +
XliffUtil.tuCountOfLangPair(filePath, langPair[0], langPair[1], false));
}
}
@Ignore
@Test
public void Test1() {
System.out.println(FileUtil.getExecutionPath());
System.out.println(FileUtil.getWorkspacePath());
}
}
| 4,521 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
MenuTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/demos/MenuTest.java | package net.heartsome.cat.ts.test.demos;
import static org.junit.Assert.assertTrue;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class MenuTest {
private static SWTWorkbenchBot bot;
@BeforeClass
public static void beforeClass() throws Exception {
bot = new SWTWorkbenchBot();
}
@Test
public void validateFileMenuStartsEnabled() {
assertTrue(bot.menu("File").isEnabled());
}
}
| 596 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
FileOperationTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.cat.ts.test/src/net/heartsome/cat/ts/test/demos/FileOperationTest.java | package net.heartsome.cat.ts.test.demos;
import net.heartsome.cat.ts.test.ui.dialogs.OpenFileDialog;
import net.heartsome.cat.ts.test.ui.dialogs.TS;
import net.heartsome.cat.ts.test.ui.views.ProjectTreeView;
import net.heartsome.test.swtbot.junit.HSJunit4ClassRunner;
import net.heartsome.test.swtbot.utils.HSBot;
import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(HSJunit4ClassRunner.class)
public class FileOperationTest {
SWTWorkbenchBot bot;
TS ts;
String prjName;
String prjFileName;
String extFilePath;
@Before
public void setUp() {
bot = HSBot.bot();
ts = TS.getInstance();
prjName = "prjBot-001";
prjFileName = "HSCAT8-23.xlf";
extFilePath = "D:\\Temp\\Sample_1.xlf";
bot.closeAllEditors();
}
@After
public void tearDown() {
bot.sleep(500);
}
@Test
public void OpenExternalFile() {
ts.menuFileOpenFile().click();
OpenFileDialog.openFile(extFilePath);
}
@Test
public void OpenWorkspaceFile() {
ProjectTreeView.doubleClickXlfFile(prjName, prjFileName);
}
}
| 1,130 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
Series.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/Series.java | package net.heartsome.license;
public class Series {
public native String getSeries();
}
| 91 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
WindowsSeries.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/WindowsSeries.java | package net.heartsome.license;
public class WindowsSeries implements SeriesInterface {
static {
try {
// String realLibName = System.mapLibraryName("win_x86_Series");
// File f = new File("lib", realLibName);
// f = f.getCanonicalFile();
// System.load(f.getAbsolutePath());
System.loadLibrary("win_x86_Series_"
+ System.getProperty("sun.arch.data.model") + "bit");
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public String getSeries() {
return new Series().getSeries();
}
}
| 531 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ProtectionFactory.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/ProtectionFactory.java | package net.heartsome.license;
import java.io.File;
import net.heartsome.license.encrypt.Encrypt;
import net.heartsome.license.encrypt.EncryptRSA;
import net.heartsome.license.utils.OsUtil;
public class ProtectionFactory {
public static String getSeries() {
SeriesInterface s;
if (OsUtil.isWindows()) {
s = new WindowsSeries();
} else if (OsUtil.isMac()) {
s = new MacosxSeries();
} else {
s = new LinuxSeries();
}
return s.getSeries();
}
public static Encrypt getEncrypt() throws Exception {
Encrypt en = new EncryptRSA();
return en;
}
public static String getFileName(int type, int productId) {
String fileName = type == 1 ? "test" : "install";
String folder = "";
if (OsUtil.isWindows()) {
folder = System.getenv("windir");
File f1 = new File(folder);
if (!f1.exists()) {
f1.mkdirs();
}
return System.getenv("windir") + "\\" + fileName + productId
+ ".inf";
} else if (OsUtil.isMac()) {
folder = System.getProperty("user.home") + "/.local";
File f1 = new File(folder);
if (!f1.exists()) {
f1.mkdirs();
}
return System.getProperty("user.home") + "/.local" + "/" + fileName
+ productId + ".eps";
} else {
folder = System.getProperty("user.home") + "/.local";
File f1 = new File(folder);
if (!f1.exists()) {
f1.mkdirs();
}
return System.getProperty("user.home") + "/.local" + "/" + fileName
+ productId + ".msl";
}
}
}
| 1,441 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
LinuxSeries.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/LinuxSeries.java | package net.heartsome.license;
import java.io.File;
import net.heartsome.license.utils.StringUtils;
import org.safehaus.uuid.EthernetAddress;
import org.safehaus.uuid.NativeInterfaces;
public class LinuxSeries implements SeriesInterface {
@Override
public String getSeries() {
// try {
NativeInterfaces.setLibDir(new File("lib"));
// NativeInterfaces.setLibDir(new File(FileLocator.toFileURL(Platform.getBundle("net.heartsome.license").getEntry("")).getPath()));
EthernetAddress[] macs = NativeInterfaces.getAllInterfaces();
String series = "";
for (EthernetAddress a : macs) {
series += a.toString() + "+";
}
return "".equals(series) ? null : StringUtils.removeColon(series.substring(0, series.length() - 1));
// } catch (IOException e) {
// e.printStackTrace();
// return null;
// }
}
}
| 830 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
LicenseIdValidator.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/LicenseIdValidator.java | package net.heartsome.license;
import net.heartsome.license.constants.Constants;
import net.heartsome.license.generator.LicenseIdGenerator;
public class LicenseIdValidator {
private boolean isTrial;
public boolean checkLicense(String licenseId) {
if (licenseId.length() != 24) {
return false;
}
LicenseIdGenerator gen = new LicenseIdGenerator(licenseId);
String temp = gen.getIsTrial();
if (!Constants.TYPE_TMEP.equals(temp) && !Constants.TYPE_BUSINESS.equals(temp)) {
return false;
}
isTrial = Constants.TYPE_TMEP.equals(temp);
if (!System.getProperty("TSVersion").equals(gen.getProductId())) {
return false;
}
if (!System.getProperty("TSEdition").equals(gen.getVersion())) {
return false;
}
return true;
}
public boolean getType() {
return isTrial;
}
}
| 813 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
LocalAuthorizationValidator.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/LocalAuthorizationValidator.java | package net.heartsome.license;
import net.heartsome.license.constants.Constants;
import net.heartsome.license.encrypt.InstallKeyEncrypt;
import net.heartsome.license.utils.FileUtils;
public class LocalAuthorizationValidator {
private boolean isTrial = false;
private String licenseId = "";
private String s;
private byte[] b;
public int checkLicense() {
LicenseReader reader = new LicenseReader(Constants.PRODUCTID);
s = reader.getLicenseInfo();
if (s == null) {
return Constants.STATE_INVALID;
}
String[] arrInfo = getStrFromInfo(s);
// 修改分隔符之后，旧版本的许可文件会导致异常，所以需要在这里判断一下，如果有异常，则会删掉原有文件，重新激活即可。
if (arrInfo.length<3){
return Constants.STATE_INVALID;
}
String strKeyCode = arrInfo[0];
String strMacCode = arrInfo[1];
String strInstallCode = arrInfo[2];
LicenseIdValidator va = new LicenseIdValidator();
if (!va.checkLicense(strKeyCode)) {
return Constants.STATE_INVALID;
}
licenseId = strKeyCode;
isTrial = va.getType();
b = FileUtils.readFile(ProtectionFactory.getFileName(2, Constants.PRODUCTID));
if (b == null) {
return Constants.STATE_INVALID;
}
try {
b = InstallKeyEncrypt.decrypt(b);
} catch (Exception e) {
e.printStackTrace();
return Constants.STATE_INVALID;
}
if (!strInstallCode.equals(new String(b))) {
return Constants.STATE_INVALID;
}
if (!compareMacCode(ProtectionFactory.getSeries(), strMacCode)) {
return Constants.STATE_INVALID;
}
return Constants.STATE_VALID;
}
private String[] getStrFromInfo(String info) {
return info.split(Constants.SEPARATOR);
}
/**
* 比较两个硬件指纹是否可以认定为同一台机器的方法
*
* @param curMacCode
* @param parmMacCode
* @return
*/
private boolean compareMacCode(String curMacCode, String parmMacCode) {
if (curMacCode == null) {
return false;
}
if (curMacCode.equals(parmMacCode)) {
return true;
} else {
String[] str1 = curMacCode.split("%");
String[] str2 = parmMacCode.split("%");
if (str1.length == str2.length) {
if (str1.length == 1) {
String[] str3 = curMacCode.split("[+]");
String[] str4 = parmMacCode.split("[+]");
for (int i = 0; i < str3.length; i++) {
for (int j = 0; j < str4.length; j++) {
if (str3[i].equals(str4[j])) {
return true;
}
}
}
} else if (str1.length == 3) {
if (str1[0].equals(str2[0]) && str1[1].equals(str2[1])) {
String[] str3 = str1[2].split("[+]");
String[] str4 = str2[2].split("[+]");
for (int i = 0; i < str3.length; i++) {
for (int j = 0; j < str4.length; j++) {
if (str3[i].equals(str4[j])) {
return true;
}
}
}
}
}
}
}
return false;
}
public boolean isTrial() {
return isTrial;
}
public String getLicenseId() {
return licenseId;
}
public String getLicenseInfo() {
return s;
}
public byte[] getInstall() {
return b;
}
}
| 3,075 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
MacosxSeries.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/MacosxSeries.java | package net.heartsome.license;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
public class MacosxSeries implements SeriesInterface {
@Override
public String getSeries() {
try {
String[] commands = new String[] {"/bin/bash", "-c", "ioreg -rd1 -c IOPlatformExpertDevice | " +
"awk '/IOPlatformSerialNumber/ { split($0, line, \"\\\"\"); printf(\"%s\\n\", line[4]); }'"};
Process process = Runtime.getRuntime().exec(commands);
ReadThread inputReadThread = new ReadThread(process.getInputStream());
inputReadThread.start();
//确保标准与错误流都读完时才向外界返回执行结果
while (true) {
if (inputReadThread.flag) {
break;
} else {
Thread.sleep(1000);
}
}
String series = inputReadThread.getResult();
return "".equals(series) ? null : series;
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
return null;
}
/*
* 标准流与错误流读取线程
*/
private static class ReadThread extends Thread {
private InputStream is;
private ArrayList<Byte> result = new ArrayList<Byte>();
public boolean flag;// 流是否读取完毕
public ReadThread(InputStream is) {
this.is = is;
}
// 获取命令执行后输出信息，如果没有则返回空""字符串
protected String getResult() {
byte[] byteArr = new byte[result.size()];
for (int i = 0; i < result.size(); i++) {
byteArr[i] = ((Byte) result.get(i)).byteValue();
}
return new String(byteArr);
}
public void run() {
try {
int readInt = is.read();
while (readInt != -1) {
result.add(Byte.valueOf(String.valueOf((byte) readInt)));
readInt = is.read();
}
flag = true;// 流已读完
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
| 1,865 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
LicenseReader.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/LicenseReader.java | package net.heartsome.license;
import net.heartsome.license.utils.FileUtils;
public class LicenseReader {
private int productId;
private byte[] key = new byte[] {48,-126,4,-67,2,1,0,48,13,6,9,42,-122,72,-122,-9,13,1,1,1,5,0,4,-126,4,-89,48,-126,4,-93,2,1,0,2,
-126,1,1,0,-116,-31,33,-26,26,115,95,-111,-97,62,29,91,-68,-26,19,56,-16,16,115,-127,-120,-58,-20,-52,-2,56,23,-2,-68,
43,-20,-53,61,16,-10,35,-66,-5,-6,-69,-61,109,69,-26,74,-103,124,-34,-117,-28,-19,93,105,-47,-15,-27,-115,-41,-69,10,
20,51,-54,70,-93,108,28,85,87,-120,95,-59,-30,-44,-117,8,82,104,39,-71,53,61,50,92,15,-64,-40,121,-55,21,10,86,34,21,
82,69,-69,25,86,6,-105,19,-86,-86,80,109,-55,19,-81,44,-18,-114,-125,-79,-26,-83,29,90,-127,-3,-100,-86,-4,-72,34,-66,
-71,15,28,-62,93,-3,-119,-73,115,-22,-107,-90,80,-102,-41,24,3,1,-107,-26,55,-83,113,69,-47,-115,-93,7,8,70,28,-38,112,
95,-44,98,-55,51,-79,-49,-83,4,112,-6,-102,30,-86,60,-121,29,-81,-126,31,-23,-90,108,-119,94,-28,15,-22,-16,91,42,37,
-90,-43,119,120,73,105,-2,31,-64,-85,94,-101,43,-87,-6,-97,19,35,-124,53,-95,-113,94,-101,-113,-18,-52,-93,92,122,-108,
73,95,85,116,45,29,-118,20,52,-41,114,73,31,-114,-15,71,-44,-38,-91,-48,72,-54,-49,48,-118,79,98,-47,-34,37,-67,95,-81,
-67,2,3,1,0,1,2,-126,1,0,101,-115,-23,12,-31,-26,103,111,39,22,-12,-68,-21,-40,2,-27,89,-112,-46,98,-1,65,62,-12,-85,17,
-82,-94,111,-19,78,30,88,32,0,-1,85,-82,121,89,-97,16,7,-126,114,38,96,-16,96,114,31,117,-26,81,116,-119,-31,13,49,-124,
-101,121,-106,8,3,-56,108,72,76,-8,62,-23,-4,-112,-16,-60,-121,-5,19,31,-100,-76,71,-72,59,-106,-19,-74,36,-15,40,-23,
92,90,120,91,81,-5,122,-102,-9,-113,50,-56,-31,127,-78,-94,-96,-11,-57,-26,46,35,49,65,123,-42,-127,-68,91,-110,-102,
-24,-10,10,-4,-123,66,-99,-7,83,56,118,27,-96,37,-64,107,120,-81,-29,87,112,-8,121,10,-93,121,-93,54,49,84,-46,-16,-69,
110,93,113,31,35,-22,-120,-121,-31,-31,17,-73,44,-31,73,114,106,7,-88,-63,48,34,43,-16,-128,-96,-24,-109,-116,92,25,39,
40,127,4,33,-26,84,-117,72,0,110,112,-6,94,23,85,115,-67,118,80,108,-110,-20,-90,-73,-27,31,-96,-115,-75,113,-29,-117,
-57,-34,3,-92,124,-8,-20,-53,31,27,-88,69,-122,-103,38,42,-15,-110,-14,3,-105,50,-26,38,-14,-44,122,88,-108,70,46,88,
-36,-75,73,-127,2,-127,-127,0,-19,-64,20,102,-53,-80,29,97,-12,68,10,-77,-84,-29,19,63,-77,3,-120,69,-38,80,-49,-52,
33,-9,25,-81,43,65,119,-40,-37,-76,5,-71,-57,26,-99,-64,41,40,38,124,-102,-60,-39,-121,32,-75,-104,12,95,-62,47,27,8,
29,68,14,-44,-78,-30,-109,-37,-41,-23,-109,-74,119,109,83,71,63,-62,-32,-126,32,103,-57,101,-95,123,6,-7,13,106,47,41,
-102,-121,122,-28,8,49,34,-90,14,-59,-47,57,-104,124,-92,115,-78,48,-103,40,-90,79,-3,66,-123,-110,99,-128,12,-5,-58,
110,105,76,-116,-126,-91,1,-31,2,-127,-127,0,-105,-79,124,-8,1,95,35,99,-57,-45,-65,44,-53,93,-18,-17,-4,1,-57,16,-46,
-115,-4,86,-19,96,-125,7,-82,98,47,38,-94,-53,-20,-45,37,86,-65,108,-57,2,108,40,31,-55,-38,-16,86,67,66,-16,104,30,
108,9,70,-26,-123,-105,-120,-106,-50,-117,31,-101,74,32,103,126,32,-83,-40,-27,-90,-22,-55,-48,124,5,-28,65,65,-102,
-52,-93,65,-65,17,112,-71,29,90,-24,-68,-84,73,-119,109,-52,-25,33,-33,-73,-85,61,78,-47,106,7,-65,43,8,87,22,78,96,
-101,85,50,-52,72,-102,-9,-88,48,33,93,2,-127,-128,25,-99,-119,85,45,-6,-14,-97,124,38,-36,-108,81,59,65,-10,-87,-3,
-26,111,-56,62,-50,-76,-86,-80,41,-41,66,-84,-46,17,-50,82,14,15,-33,16,-46,16,67,30,-19,78,-99,-118,57,-7,-94,31,
-114,-101,62,-79,-8,75,76,75,-126,-22,-86,37,-1,-35,120,97,65,-20,69,75,-122,-66,-29,61,78,108,-53,-8,91,-42,18,-16,
28,6,59,77,35,-76,-93,33,-32,24,-16,122,-91,120,-101,53,-102,64,-103,-103,1,76,-30,-98,63,56,49,54,2,6,66,101,-117,
-55,38,-95,-65,122,-72,-88,-91,-77,-71,-37,-73,97,2,-127,-127,0,-109,97,-108,-93,120,-31,-80,-122,-81,-115,-95,126,
-86,16,23,-89,-2,-42,-45,76,26,-26,108,-73,32,102,-42,-89,-51,-36,3,39,-84,-96,40,-10,116,-98,-75,-39,-65,-7,48,-112,
67,98,97,95,-124,-48,80,-25,54,-95,-24,33,-109,75,65,-100,-102,-50,-70,-38,28,-39,73,-55,-10,3,107,72,-67,37,83,105,
102,-81,50,-16,-98,118,112,-127,48,53,-90,25,55,-98,-89,-100,71,-55,60,22,-64,83,-49,-28,118,-28,72,114,48,-29,-98,
2,-124,-36,5,-10,-113,97,-35,-128,69,8,102,92,-74,114,12,110,118,112,92,-39,2,-127,-128,18,114,-71,-94,26,-65,-63,
87,-42,-61,44,-36,80,-63,97,127,40,-99,-67,-9,86,68,16,12,101,-71,75,-41,43,-15,54,119,-26,-126,-16,68,16,99,16,
22,-83,4,127,126,62,-52,42,-10,-30,-62,-9,-71,-41,-109,-22,98,-69,56,-53,-12,107,-66,106,22,19,-124,122,-74,106,
-126,-39,-27,-37,-22,-67,41,-56,-75,118,120,50,-41,-2,19,83,-48,-53,0,-69,95,-4,18,46,81,116,121,-70,124,-14,68,
-47,-35,-86,56,-34,124,27,-37,-80,56,65,-26,-17,89,121,29,-72,112,-96,98,-115,59,7,76,62,68,-73,-71};
public LicenseReader(int productId) {
this.productId = productId;
}
public String getLicenseInfo() {
byte[] b = FileUtils.readFile(ProtectionFactory.getFileName(1, productId));
if (b == null) {
return null;
}
try {
b = ProtectionFactory.getEncrypt().decrypt(key, b);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return new String(b);
}
}
| 5,105 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
LicenseCheck.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/test/LicenseCheck.java | package net.heartsome.license.test;
import net.heartsome.license.webservice.ServiceUtilTest;
import org.apache.jmeter.config.Arguments;
import org.apache.jmeter.protocol.java.sampler.AbstractJavaSamplerClient;
import org.apache.jmeter.protocol.java.sampler.JavaSamplerContext;
import org.apache.jmeter.samplers.SampleResult;
public class LicenseCheck extends AbstractJavaSamplerClient {
@Override
public SampleResult runTest(JavaSamplerContext context) {
SampleResult results = new SampleResult();
results.sampleStart();
String licenseID = context.getParameter("LicenseID");
String hardwareCode = context.getParameter("HardwareCode");
String installCode = context.getParameter("InstallCode");
int intervalTime = Integer.valueOf(context
.getParameter("IntervalSeconds")) * 1000;
String strResult = licenseID + "：\n";
long startTime = System.currentTimeMillis();
// 验证许可证的激活状态
try {
String result = ServiceUtilTest.check(licenseID, hardwareCode,
installCode);
if (result.equals("Check Success")) {
results.setSuccessful(true);
results.setResponseCodeOK();
strResult += "验证通过！\n";
} else {
results.setSuccessful(true);
results.setResponseCodeOK();
strResult += "验证未通过，返回结果为：" + result + "\n";
}
} catch (Exception e) {
results.setSuccessful(false);
strResult += "验证失败，异常信息：\n" + e.getMessage() + "\n";
}
// 等待两次测试之间的间隔
if (intervalTime != 0) {
try {
Thread.sleep(intervalTime);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
}
long pastTime = System.currentTimeMillis() - startTime - intervalTime;
results.setResponseMessage(strResult + "\n实际耗时（毫秒）：" + pastTime);
results.sampleEnd();
return results;
}
public Arguments getDefaultParameters() {
Arguments args = new Arguments();
args.addArgument("LicenseID", "89U1jiKrhD5IG1yNU0O2CinG");
args.addArgument("HardwareCode", "TestHW");
args.addArgument("InstallCode", "TestInstall");
args.addArgument("IntervalSeconds", "30");
return args;
}
}
| 2,149 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
LicenseActivateCheckDeactivate.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/test/LicenseActivateCheckDeactivate.java | package net.heartsome.license.test;
import net.heartsome.license.constants.Constants;
import net.heartsome.license.webservice.ServiceUtilTest;
import org.apache.jmeter.config.Arguments;
import org.apache.jmeter.protocol.java.sampler.AbstractJavaSamplerClient;
import org.apache.jmeter.protocol.java.sampler.JavaSamplerContext;
import org.apache.jmeter.samplers.SampleResult;
public class LicenseActivateCheckDeactivate extends AbstractJavaSamplerClient {
private SampleResult results;
private String licenseID;
private String hardwareCode;
private String installCode;
private int waitTimeMillis;
private int intervalTimeMillis;
private String strResult;
private long startTime;
private long pastTime;
private int waitCount = 0;
@Override
public SampleResult runTest(JavaSamplerContext context) {
results = new SampleResult();
results.sampleStart();
licenseID = context.getParameter("LicenseID");
hardwareCode = context.getParameter("HardwareCode");
installCode = context.getParameter("InstallCode");
waitTimeMillis = Integer.valueOf(context.getParameter("WaitSeconds")) * 1000;
intervalTimeMillis = Integer.valueOf(context
.getParameter("IntervalSeconds")) * 1000;
strResult = licenseID + "：\n";
startTime = System.currentTimeMillis();
// 检查许可证状态，应为未激活，然后激活
check(NextAction.ACTIVATE, "不通过");
// 等待两次测试之间的间隔时间
wait(intervalTimeMillis);
pastTime = System.currentTimeMillis() - startTime - waitTimeMillis
* waitCount - intervalTimeMillis;
results.setResponseMessage(strResult + "\n实际耗时（毫秒）：" + pastTime);
results.sampleEnd();
return results;
}
public Arguments getDefaultParameters() {
Arguments args = new Arguments();
args.addArgument("LicenseID", "89U1jiKrhD5IG1yNU0O2CinG");
args.addArgument("HardwareCode", "TestHW");
args.addArgument("InstallCode", "TestInstall");
args.addArgument("WaitSeconds", "5");
args.addArgument("IntervalSeconds", "30");
return args;
}
/**
* 检查许可证状态，
*
* @param na
* 检查后的下一步操作
* @param expected
* 预期检查结果
*/
private void check(NextAction na, String expected) {
try {
String result = ServiceUtilTest.check(licenseID, hardwareCode,
installCode);
if (result.equals("Check Success")) {
strResult += ("预期" + expected + "，验证通过！\n");
// 若下一步为取消激活，则当前应该是已激活
if (na.equals(NextAction.DEACTIVATE)) {
results.setSuccessful(true);
wait(waitTimeMillis);
deactivate();
// 否则应该为未激活状态，非预期结果，故测试失败
} else {
results.setSuccessful(false);
}
} else {
strResult += ("预期" + expected + "，验证未通过，返回结果为：" + result + "\n");
// 下一步为激活，则当前应为未激活
if (na.equals(NextAction.ACTIVATE)) {
results.setSuccessful(true);
wait(waitTimeMillis);
activate();
// 若测试结束，应已成功取消激活
} else if (na.equals(NextAction.END)) {
results.setSuccessful(true);
results.setResponseCodeOK();
// 否则应为已激活状态，非预期结果，故测试失败
} else {
results.setSuccessful(false);
}
}
} catch (Exception e) {
results.setSuccessful(false);
strResult += "验证失败，异常信息：\n" + e.getMessage() + "\n";
}
}
/**
* 激活许可证
*/
private void activate() {
try {
String result = ServiceUtilTest.active(licenseID, hardwareCode,
installCode);
if (result.equals("Active Success")) {
strResult += "激活成功！\n";
results.setSuccessful(true);
// 等待指定时间
wait(waitTimeMillis);
// 检查许可证激活状态，并指定下一步操作为取消激活
check(NextAction.DEACTIVATE, "通过");
} else {
results.setSuccessful(false);
strResult = strResult + "激活失败，返回结果为：" + result + "\n";
}
} catch (Exception e) {
// e.printStackTrace();
results.setSuccessful(false);
strResult = strResult + "激活失败，异常信息：\n" + e.getMessage() + "\n";
}
}
/**
* 取消激活许可证
*/
private void deactivate() {
try {
String result = ServiceUtilTest.cancel(licenseID, hardwareCode,
installCode);
if (Constants.RETURN_LOGOUTSUCESS.equals(result)) {
results.setSuccessful(true);
strResult += "取消激活成功！\n";
// 等待指定时间
wait(waitTimeMillis);
// 检查许可证激活状态，并指明测试结束
check(NextAction.END, "不通过");
} else {
results.setSuccessful(false);
strResult += "取消激活失败，返回结果为：" + result + "\n";
}
} catch (Exception e) {
results.setSuccessful(false);
strResult += "取消激活失败，异常信息：\n" + e.getMessage() + "\n";
}
}
/**
* 等待指定毫秒数
*
* @param waitTimeMillis
*/
private void wait(int waitTimeMillis) {
if (waitTimeMillis != 0) {
try {
Thread.sleep(waitTimeMillis);
waitCount++;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* @author felix_lu 下一步操作：激活、取消激活、结束
*/
private enum NextAction {
ACTIVATE, DEACTIVATE, END
}
}
| 5,373 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
RandomUtils.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/utils/RandomUtils.java | package net.heartsome.license.utils;
public class RandomUtils {
public static String generateRandom(int num) {
char[] temp = new char[] {'0','1','2','3','4','5','6','7','8','9',
'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','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'};
int size = temp.length;
StringBuffer bu = new StringBuffer();
for (int i = 0; i < num; i++) {
int r = (int)(Math.random() * size);
bu.append(temp[r]);
}
return bu.toString();
}
}
| 612 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
DateUtils.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/utils/DateUtils.java | package net.heartsome.license.utils;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateUtils {
public static String getDate() {
Date date = new Date();
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
return format.format(date);
}
}
| 283 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
OsUtil.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/utils/OsUtil.java | package net.heartsome.license.utils;
public class OsUtil {
public static String getOS() {
return System.getProperty("os.name");
}
public static boolean isWindows() {
return getOS().startsWith("Windows");
}
public static boolean isMac() {
return getOS().startsWith("Mac");
}
public static boolean isLinux() {
return getOS().startsWith("Linux");
}
public static void main(String[] args) {
System.out.println(getOS());
}
}
| 452 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
FileUtils.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/utils/FileUtils.java | package net.heartsome.license.utils;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import net.heartsome.license.ProtectionFactory;
import net.heartsome.license.constants.Constants;
public class FileUtils {
public static void writeFile(byte[] b, String fileName) {
try {
DataOutputStream out = new DataOutputStream(new FileOutputStream(
fileName));
out.write(b);
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static byte[] readFile(String fileName) {
try {
DataInputStream in = new DataInputStream(new BufferedInputStream(
new FileInputStream(fileName)));
int n = in.available();
byte[] t = new byte[n];
int i = 0;
while (in.available() != 0) {
t[i] = in.readByte();
i++;
}
in.close();
return t;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static boolean removeFile() {
boolean flag1 = false;
boolean flag2 = false;
File file = new File(ProtectionFactory.getFileName(1, Constants.PRODUCTID));
if (file.isFile() && file.exists()) {
file.delete();
flag1 = true;
}
file = new File(ProtectionFactory.getFileName(2, Constants.PRODUCTID));
if (file.isFile() && file.exists()) {
file.delete();
flag2 = true;
}
return flag1 && flag2;
}
public static boolean isExsit() {
boolean flag1 = false;
boolean flag2 = false;
File file = new File(ProtectionFactory.getFileName(1, Constants.PRODUCTID));
if (file.isFile() && file.exists()) {
flag1 = true;
}
file = new File(ProtectionFactory.getFileName(2, Constants.PRODUCTID));
if (file.isFile() && file.exists()) {
flag2 = true;
}
return flag1 && flag2;
}
}
| 1,938 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
StringUtils.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/utils/StringUtils.java | package net.heartsome.license.utils;
public class StringUtils {
public static String handle(String key, int interval, int start, int num) {
char[] temp = new char[] {'0','1','2','3','4','5','6','7','8','9'};
int size = temp.length;
StringBuffer bu = new StringBuffer(key);
int length = key.length();
for (int i = start; i < length;) {
for (int j = 0; j < num; j++) {
int r = (int)(Math.random() * size);
bu.insert(i, temp[r]);
}
i += interval + num;
length += num;
}
return bu.toString();
}
public static String reverse(String key, int interval, int start, int num) {
StringBuffer bu = new StringBuffer(key);
int length = key.length();
for (int i = start; i < length;) {
for (int j = 0; j < num; j++) {
bu.deleteCharAt(i);
}
i += interval;
length -= num;
}
return bu.toString();
}
public static String removeColon(String str) {
return str.replaceAll(":", "");
}
public static String toHexString(byte[] b) {
StringBuilder sb = new StringBuilder(b.length * 2);
for (int i = 0; i < b.length; i++) {
sb.append(HEXCHAR[(b[i] & 0xf0) >>> 4]);
sb.append(HEXCHAR[b[i] & 0x0f]);
}
return sb.toString();
}
public static byte[] toBytes(String s) {
byte[] bytes;
bytes = new byte[s.length() / 2];
for (int i = 0; i < bytes.length; i++) {
bytes[i] = (byte) Integer.parseInt(s.substring(2 * i, 2 * i + 2),
16);
}
return bytes;
}
private static char[] HEXCHAR = { '0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
/**
* 许可 KEY，使用标准的 4 个字符一组，然后使用 - 连接。
* @return ;
*/
public static String groupString(String str) {
if (str == null || str.length() != 24) {
return str;
} else {
String temp = "";
for (int i = 0; i < 6; i++) {
temp += str.substring(i * 4, (i + 1) * 4) + "-";
}
return temp.substring(0, temp.length() - 1);
}
}
}
| 1,946 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
KeyGeneratorImpl.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/generator/KeyGeneratorImpl.java | package net.heartsome.license.generator;
import net.heartsome.license.ProtectionFactory;
import net.heartsome.license.constants.Constants;
import net.heartsome.license.encrypt.Encrypt;
import net.heartsome.license.encrypt.EncryptRSA;
import net.heartsome.license.utils.RandomUtils;
public class KeyGeneratorImpl implements IKeyGenerator {
private static Encrypt en;
private String installKey;
public KeyGeneratorImpl() {
try {
en = new EncryptRSA();
} catch (Exception e) {
e.printStackTrace();
}
}
private String generateActiveKey(String licenseId) {
return licenseId;
}
@Override
public byte[] generateKey(String licenseId, byte[] b) throws Exception {
String key = generateActiveKey(licenseId) + Constants.SEPARATOR + ProtectionFactory.getSeries()
+ Constants.SEPARATOR + generateInstallKey();
// System.out.println("原文：" + key);
return en.encrypt(b, key.getBytes());
}
private String generateInstallKey() {
installKey = RandomUtils.generateRandom(20);
return installKey;
}
public static void main(String[] argv) {
KeyGeneratorImpl impl = new KeyGeneratorImpl();
try {
impl.generateKey("111", en.getPublicKey());
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public String getInstallKey() {
return installKey;
}
@Override
public byte[] generateKey(String licenseId, String installKey, byte[] b)
throws Exception {
String key = licenseId + Constants.SEPARATOR + ProtectionFactory.getSeries()
+ Constants.SEPARATOR + installKey;
return en.encrypt(b, key.getBytes());
}
}
| 1,580 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
IKeyGenerator.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/generator/IKeyGenerator.java | package net.heartsome.license.generator;
public interface IKeyGenerator {
byte[] generateKey(String licenseId, byte[] b) throws Exception;
byte[] generateKey(String licenseId, String installKey, byte[] b) throws Exception;
String getInstallKey();
}
| 257 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
LicenseIdGenerator.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/generator/LicenseIdGenerator.java | package net.heartsome.license.generator;
import net.heartsome.license.utils.RandomUtils;
public class LicenseIdGenerator {
private String licenseId;
public LicenseIdGenerator(String licenseId) {
this.licenseId = licenseId;
}
public LicenseIdGenerator(String productId, String version, String isTrial) {
this.licenseId = productId + version + isTrial + RandomUtils.generateRandom(20);
}
public String getProductId() {
if (licenseId == null) {
return null;
}
return licenseId.substring(0, 2);
}
public String getVersion() {
if (licenseId == null) {
return null;
}
return licenseId.substring(2, 3);
}
public String getIsTrial() {
if (licenseId == null) {
return null;
}
return licenseId.substring(3, 4);
}
}
| 761 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
Encrypt.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/encrypt/Encrypt.java | package net.heartsome.license.encrypt;
public interface Encrypt {
byte[] getPublicKey();
byte[] getPrivateKey();
byte[] encrypt(byte[] publicKeyArray, byte[] srcBytes) throws Exception;
byte[] decrypt(byte[] privateKeyArray, byte[] srcBytes) throws Exception;
}
| 270 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
EncryptRSA.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/encrypt/EncryptRSA.java | package net.heartsome.license.encrypt;
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;
public class EncryptRSA implements Encrypt {
// 非对称加密密钥算法
private static final String algorithm = "RSA";
// 密钥长度，用来初始化
private static final int key_size = 1024;
// 公钥
private final byte[] publicKey;
// 私钥
private final byte[] privateKey;
public EncryptRSA() throws Exception {
SecureRandom sr = new SecureRandom();
KeyPairGenerator kpg = KeyPairGenerator.getInstance(algorithm);
kpg.initialize(key_size, sr);
KeyPair kp = kpg.generateKeyPair();
Key keyPublic = kp.getPublic();
publicKey = keyPublic.getEncoded();
Key keyPrivate = kp.getPrivate();
privateKey = keyPrivate.getEncoded();
}
/**
* 加密
*
* @param publicKeyArray
* @param srcBytes
* @return
* @throws Exception
*/
public byte[] encrypt(byte[] publicKeyArray, byte[] srcBytes)
throws Exception {
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyArray);
KeyFactory kf = KeyFactory.getInstance(algorithm);
PublicKey keyPublic = kf.generatePublic(keySpec);
Cipher cipher;
cipher = Cipher.getInstance(algorithm,
new org.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(Cipher.ENCRYPT_MODE, keyPublic);
int blockSize = cipher.getBlockSize();
int outputSize = cipher.getOutputSize(srcBytes.length);
int leavedSize = srcBytes.length % blockSize;
int blocksSize = leavedSize != 0 ? srcBytes.length / blockSize + 1
: srcBytes.length / blockSize;
byte[] raw = new byte[outputSize * blocksSize];
int i = 0;
while (srcBytes.length - i * blockSize > 0) {
if (srcBytes.length - i * blockSize > blockSize)
cipher.doFinal(srcBytes, i * blockSize, blockSize, raw, i
* outputSize);
else
cipher.doFinal(srcBytes, i * blockSize, srcBytes.length - i
* blockSize, raw, i * outputSize);
i++;
}
return raw;
}
/**
* 解密
*
* @param privateKeyArray
* @param srcBytes
* @return
* @throws Exception
*/
public byte[] decrypt(byte[] privateKeyArray, byte[] srcBytes)
throws Exception {
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyArray);
KeyFactory kf = KeyFactory.getInstance(algorithm);
PrivateKey keyPrivate = kf.generatePrivate(keySpec);
Cipher cipher = Cipher.getInstance(algorithm,
new org.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(Cipher.DECRYPT_MODE, keyPrivate);
int blockSize = cipher.getBlockSize();
ByteArrayOutputStream bout = new ByteArrayOutputStream(blockSize);
int j = 0;
while (srcBytes.length - j * blockSize > 0) {
byte[] temp = cipher.doFinal(srcBytes, j * blockSize, blockSize);
bout.write(temp);
j++;
}
return bout.toByteArray();
}
public byte[] getPublicKey() {
return publicKey;
}
public byte[] getPrivateKey() {
return privateKey;
}
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
EncryptRSA rsa = new EncryptRSA();
String msg = "都是考虑考虑对方都是考虑考虑对方都是考虑考虑对方都是考虑考虑对方都是考虑考虑对方" +
"都是考虑考虑对方都是考虑考虑对方都是考虑考虑对方都是考虑考虑对方都是考虑考虑对方都是考虑" +
"都是考虑考虑对方都是考虑考虑对方都是考虑考虑对方都是考虑考虑对方考虑对方";
byte[] srcBytes = msg.getBytes();
byte[] resultBytes = rsa.encrypt(rsa.getPublicKey(), srcBytes);
byte[] decBytes = rsa.decrypt(rsa.getPrivateKey(), resultBytes);
System.out.println("原文:" + msg);
System.out.println("加密后:" + new String(resultBytes));
System.out.println("解密后:" + new String(decBytes));
}
}
| 4,121 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
InstallKeyEncrypt.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/encrypt/InstallKeyEncrypt.java | package net.heartsome.license.encrypt;
import java.io.ByteArrayOutputStream;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;
public class InstallKeyEncrypt {
private static final String algorithm = "RSA";
private final static byte[] publicKey = new byte[] {48,-127,-97,48,13,6,9,42,-122,72,-122,-9,13,1,1,1,5,0,3,
-127,-115,0,48,-127,-119,2,-127,-127,0,-126,84,87,97,-103,60,114,-92,-21,23,111,34,-45,61,8,
-39,-18,-95,96,-99,-4,-15,-51,52,-82,91,-108,-102,87,-37,-8,34,23,-16,98,-100,38,-7,82,-13,
67,47,96,-102,-128,-48,21,-106,-94,23,119,-77,-46,72,-89,-44,64,-11,81,127,26,-38,-59,26,102,
-58,-89,104,-117,88,87,-93,-9,110,-21,-102,-24,-72,-23,-41,45,7,-35,-72,-105,-98,-27,-114,-74,
-49,-35,-93,-85,66,111,-72,-4,58,-116,-93,-102,27,-49,-25,32,75,4,-2,-95,112,-60,-103,32,43,31,
60,18,-89,24,-85,-63,-95,73,-115,13,22,-102,-25,2,3,1,0,1};
private final static byte[] privateKey = new byte[] {48,-126,2,118,2,1,0,48,13,6,9,42,-122,72,-122,-9,13,1,1,
1,5,0,4,-126,2,96,48,-126,2,92,2,1,0,2,-127,-127,0,-126,84,87,97,-103,60,114,-92,-21,23,111,
34,-45,61,8,-39,-18,-95,96,-99,-4,-15,-51,52,-82,91,-108,-102,87,-37,-8,34,23,-16,98,-100,38,
-7,82,-13,67,47,96,-102,-128,-48,21,-106,-94,23,119,-77,-46,72,-89,-44,64,-11,81,127,26,-38,
-59,26,102,-58,-89,104,-117,88,87,-93,-9,110,-21,-102,-24,-72,-23,-41,45,7,-35,-72,-105,-98,
-27,-114,-74,-49,-35,-93,-85,66,111,-72,-4,58,-116,-93,-102,27,-49,-25,32,75,4,-2,-95,112,
-60,-103,32,43,31,60,18,-89,24,-85,-63,-95,73,-115,13,22,-102,-25,2,3,1,0,1,2,-127,-128,78,
45,-21,-48,-25,12,4,-75,123,52,-82,125,20,124,11,96,55,-82,100,119,-63,49,7,104,-81,-94,-50,
12,-101,-31,-97,2,76,-101,-19,123,64,65,-43,-119,-119,102,-43,43,57,84,25,111,39,-62,-82,18,
-105,116,-17,-1,-6,11,110,-100,-79,110,68,71,66,-54,27,-119,-66,25,-60,-57,27,-36,44,48,95,
-49,-34,97,85,22,116,88,-109,-73,-55,-106,56,-6,-45,16,-85,72,-84,-120,126,-41,-26,10,58,61,
-83,-21,-86,51,44,-51,-65,-82,-51,-69,124,105,-86,11,-69,83,-82,-70,78,116,13,-13,-82,111,
-121,33,2,65,0,-13,-81,-101,117,47,-74,84,88,-98,49,-117,99,-75,-82,-122,-19,-86,-11,-118,
-19,103,-118,-94,-39,-9,87,18,-39,12,7,126,9,-16,-67,-104,77,-80,-91,112,-125,-88,-59,32,
120,-96,-120,-18,-123,36,-25,-105,-99,12,96,91,90,0,0,-108,67,95,-18,-15,-79,2,65,0,-120,
-22,82,59,-32,75,-106,-88,120,99,-5,-10,87,104,89,-38,85,27,-45,-17,-77,4,81,78,55,30,-65,
2,35,-63,-54,-33,65,-113,83,57,-82,105,-29,107,-98,114,1,103,106,12,120,26,-110,14,-72,-26,
116,-4,-22,24,72,27,-94,-44,21,66,36,23,2,64,14,-47,65,-63,-87,106,11,-52,-21,-87,-107,-111,
53,-115,-20,52,109,109,-54,-55,-50,-66,-10,82,12,-95,37,-53,62,-39,1,-57,-10,-12,-128,91,80,
-1,110,77,3,41,33,101,84,85,-97,51,71,96,49,-82,-31,-2,-59,-17,62,10,-54,-7,33,-49,52,-79,2,
65,0,-120,88,80,-20,47,-63,22,-105,78,-52,-62,-19,-34,-67,-100,61,64,-28,37,122,94,-37,-67,
-36,22,40,24,47,25,76,-77,-85,0,-82,-86,66,-106,-35,-4,12,0,13,-88,56,67,-13,-122,-25,110,
-20,26,85,-27,-54,-73,-108,-42,-70,46,-68,-27,46,-88,-95,2,64,72,69,76,-106,-91,82,-34,-14,
-15,-115,119,-51,-7,-12,46,34,79,44,-89,32,123,46,-100,-5,-35,-72,96,-33,-2,93,31,-94,-3,15,
-56,-109,-8,112,-116,67,68,-125,63,73,-78,-93,65,-110,29,5,-23,-15,80,9,-52,-125,-67,-81,-40,
76,70,104,51,-59};
public static byte[] encrypt(byte[] srcBytes) throws Exception {
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
KeyFactory kf = KeyFactory.getInstance(algorithm);
PublicKey keyPublic = kf.generatePublic(keySpec);
Cipher cipher;
cipher = Cipher.getInstance(algorithm,
new org.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(Cipher.ENCRYPT_MODE, keyPublic);
int blockSize = cipher.getBlockSize();
int outputSize = cipher.getOutputSize(srcBytes.length);
int leavedSize = srcBytes.length % blockSize;
int blocksSize = leavedSize != 0 ? srcBytes.length / blockSize + 1
: srcBytes.length / blockSize;
byte[] raw = new byte[outputSize * blocksSize];
int i = 0;
while (srcBytes.length - i * blockSize > 0) {
if (srcBytes.length - i * blockSize > blockSize)
cipher.doFinal(srcBytes, i * blockSize, blockSize, raw, i
* outputSize);
else
cipher.doFinal(srcBytes, i * blockSize, srcBytes.length - i
* blockSize, raw, i * outputSize);
i++;
}
return raw;
}
public static byte[] decrypt(byte[] srcBytes) throws Exception {
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
KeyFactory kf = KeyFactory.getInstance(algorithm);
PrivateKey keyPrivate = kf.generatePrivate(keySpec);
Cipher cipher = Cipher.getInstance(algorithm,
new org.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(Cipher.DECRYPT_MODE, keyPrivate);
int blockSize = cipher.getBlockSize();
ByteArrayOutputStream bout = new ByteArrayOutputStream(blockSize);
int j = 0;
while (srcBytes.length - j * blockSize > 0) {
byte[] temp = cipher.doFinal(srcBytes, j * blockSize, blockSize);
bout.write(temp);
j++;
}
return bout.toByteArray();
}
}
| 5,221 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ServiceUtilTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/webservice/ServiceUtilTest.java | package net.heartsome.license.webservice;
import java.lang.reflect.Proxy;
import java.net.MalformedURLException;
import net.heartsome.license.ProtectionFactory;
import net.heartsome.license.constants.Constants;
import net.heartsome.license.encrypt.Encrypt;
import net.heartsome.license.utils.StringUtils;
import org.apache.commons.httpclient.protocol.Protocol;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
import org.codehaus.xfire.client.Client;
import org.codehaus.xfire.client.XFireProxy;
import org.codehaus.xfire.client.XFireProxyFactory;
import org.codehaus.xfire.service.Service;
import org.codehaus.xfire.service.binding.ObjectServiceFactory;
import org.codehaus.xfire.transport.http.CommonsHttpMessageSender;
import org.codehaus.xfire.transport.http.EasySSLProtocolSocketFactory;
import org.codehaus.xfire.util.dom.DOMOutHandler;
public class ServiceUtilTest {
private static final String SERVICE_URL = "https://lic.heartsome.net/hswebservices/licenses";
private static final String SERVICE_NAMESPACE = "licenses.XFire";
private static final String SERVICE_NAME = "licenses";
private static final String HTTP_TYPE = "https";
private static final int PORT = 443;
public static IService getService() throws MalformedURLException {
// Service srvcModel = new
// ObjectServiceFactory().create(IService.class);
// XFireProxyFactory factory = new XFireProxyFactory(XFireFactory
// .newInstance().getXFire());
//
// IService srvc = (IService) factory.create(srvcModel,
// Constants.CONNECT_URL);
// return srvc;
ProtocolSocketFactory easy = new EasySSLProtocolSocketFactory();
Protocol protocol = new Protocol(HTTP_TYPE, easy, PORT);
Protocol.registerProtocol(HTTP_TYPE, protocol);
Service serviceModel = new ObjectServiceFactory().create(
IService.class, SERVICE_NAME, SERVICE_NAMESPACE, null);
IService service = (IService) new XFireProxyFactory().create(
serviceModel, SERVICE_URL);
Client client = ((XFireProxy) Proxy.getInvocationHandler(service))
.getClient();
client.addOutHandler(new DOMOutHandler());
client.setProperty(CommonsHttpMessageSender.GZIP_ENABLED, Boolean.FALSE);
client.setProperty(CommonsHttpMessageSender.DISABLE_EXPECT_CONTINUE,
"1");
client.setProperty(CommonsHttpMessageSender.HTTP_TIMEOUT, "0");
return service;
}
public static String active(String licenseId, String maccode,
String installcode) throws Exception {
IService srvc = ServiceUtil.getService();
byte[] serverPublicKey = srvc.getServerPublicKey();
String s = licenseId + Constants.SEPARATOR
+ ProtectionFactory.getSeries() + Constants.SEPARATOR
+ installcode;
Encrypt en = ProtectionFactory.getEncrypt();
byte[] k = en.encrypt(serverPublicKey, s.getBytes());
String str = srvc.activeLicense(StringUtils.toHexString(k),
en.getPublicKey());
byte[] b = StringUtils.toBytes(str);
b = en.decrypt(en.getPrivateKey(), b);
// System.out.println(new String(b));
if (Constants.RETURN_INVALIDLICENSE.equals(new String(b))) {
return Constants.RETURN_INVALIDLICENSE;
} else if (Constants.RETURN_INVALIDBUNDLE.equals(new String(b))) {
return Constants.RETURN_INVALIDBUNDLE;
} else if (Constants.RETURN_DBEXCEPTION.equals(new String(b))) {
return Constants.RETURN_DBEXCEPTION;
} else if (Constants.RETURN_MUTILTEMPBUNDLE.equals(new String(b))) {
return Constants.RETURN_MUTILTEMPBUNDLE;
} else if (Constants.RETURN_EXPIREDLICENSE.equals(new String(b))) {
return Constants.RETURN_EXPIREDLICENSE;
} else {
return "Active Success";
}
}
public static String cancel(String licenseId, String maccode,
String installcode) throws Exception {
IService srvc = ServiceUtil.getService();
byte[] serverPublicKey = srvc.getServerPublicKey();
Encrypt en = ProtectionFactory.getEncrypt();
String info = licenseId + Constants.SEPARATOR
+ ProtectionFactory.getSeries() + Constants.SEPARATOR
+ installcode;
String str = srvc.logoutLicense(
StringUtils.toHexString(en.encrypt(serverPublicKey,
info.getBytes())), en.getPublicKey());
byte[] b = StringUtils.toBytes(str);
b = en.decrypt(en.getPrivateKey(), b);
info = new String(b);
// System.out.println(info);
// if (Constants.RETURN_LOGOUTSUCESS.equals(info)) {
// return Constants.LOGOUT_SUCCESS;
// } else if (Constants.RETURN_INVALIDLICENSE.equals(info)) {
// return Constants.LOGOUT_FAIL;
// } else {
// return Constants.LOGOUT_FAIL;
// }
return info;
}
public static String check(String licenseId, String maccode,
String installcode) throws Exception {
IService srvc = ServiceUtil.getService();
byte[] serverPublicKey = srvc.getServerPublicKey();
Encrypt en = ProtectionFactory.getEncrypt();
String info = licenseId + Constants.SEPARATOR
+ ProtectionFactory.getSeries() + Constants.SEPARATOR
+ installcode;
String str = srvc.checkLicense(
StringUtils.toHexString(en.encrypt(serverPublicKey,
info.getBytes())), en.getPublicKey());
byte[] b = StringUtils.toBytes(str);
b = en.decrypt(en.getPrivateKey(), b);
info = new String(b);
if (Constants.RETURN_CHECKSUCESS.equals(info)) {
return "Check Success";
} else if (Constants.RETURN_EXPIREDLICENSE.equals(info)) {
return "Expired";
} else {
return "Invalid";
}
}
// private static String[] getStrFromInfo(String info) {
// return info.split(Constants.SEPARATOR);
// }
// public static void main(String[] argv) {
// try {
// int result = ServiceUtilTest.active("111111111111111111111111",
// "000000000011", "11111111111111111111");
// if (result == Constants.ACTIVE_OK_INT) {
// System.out.println("激活成功");
// } else {
// System.out.println("激活失败");
// }
//
// } catch (Exception e) {
// e.printStackTrace();
// System.out.println("激活失败");
// }
//
// try {
// int result = ServiceUtilTest.cancel("111111111111111111111111",
// "000000000011", "11111111111111111111");
// if (result == Constants.LOGOUT_SUCCESS) {
// System.out.println("取消激活成功");
// } else {
// System.out.println("取消激活失败");
// }
// } catch (Exception e) {
// e.printStackTrace();
// System.out.println("取消激活失败");
// }
// }
}
| 6,386 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
IService.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/webservice/IService.java | package net.heartsome.license.webservice;
public interface IService{
public byte[] getServerPublicKey() throws Exception;
public String buyLicense(String username, String email,String productInfo);
/**
* 激活许可证
* @param info 客户端信息，包括许可证号、硬件指纹、安装码
* @param clientPublicKey 客户端公钥
* @return 激活信息
*/
public String activeLicense(String info, byte[] clientPublicKey) throws Exception;
/**
* 校验许可证
* @param info 客户端信息，包括许可证号、最新的硬件指纹
* @param clientPublicKey 客户端公钥
* @return 校验信息
*/
public String checkLicense(String info, byte[] clientPublicKey) throws Exception;
/**
* 注销许可证
* @param info 客户端信息，包括许可证号、最新的硬件指纹
* @param clientPublicKey 客户端公钥
* @return 注销信息
*/
public String logoutLicense(String info, byte[] clientPublicKey) throws Exception;
/**
* 获取试用许可证的截止日期
* @param key
* @return
*/
public String getTempEndDate(String key, byte[] clientPublicKey) throws Exception;
} | 1,175 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ServiceUtil.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/webservice/ServiceUtil.java | package net.heartsome.license.webservice;
import java.net.MalformedURLException;
import net.heartsome.license.LicenseReader;
import net.heartsome.license.ProtectionFactory;
import net.heartsome.license.constants.Constants;
import net.heartsome.license.encrypt.Encrypt;
import net.heartsome.license.encrypt.InstallKeyEncrypt;
import net.heartsome.license.generator.IKeyGenerator;
import net.heartsome.license.generator.KeyGeneratorImpl;
import net.heartsome.license.utils.FileUtils;
import net.heartsome.license.utils.StringUtils;
import java.lang.reflect.Proxy;
import org.codehaus.xfire.client.XFireProxy;
import org.apache.commons.httpclient.protocol.Protocol;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
import org.codehaus.xfire.client.Client;
import org.codehaus.xfire.client.XFireProxyFactory;
import org.codehaus.xfire.service.Service;
import org.codehaus.xfire.service.binding.ObjectServiceFactory;
import org.codehaus.xfire.transport.http.CommonsHttpMessageSender;
import org.codehaus.xfire.transport.http.EasySSLProtocolSocketFactory;
import org.codehaus.xfire.util.dom.DOMOutHandler;
public class ServiceUtil {
private static final String SERVICE_URL ="https://lic.heartsome.net/hswebservices/licenses";
private static final String SERVICE_NAMESPACE = "licenses.XFire";
private static final String SERVICE_NAME = "licenses";
private static final String HTTP_TYPE = "https";
private static final int PORT = 443;
public static IService getService() throws MalformedURLException {
// Service srvcModel = new ObjectServiceFactory().create(IService.class);
// XFireProxyFactory factory = new XFireProxyFactory(XFireFactory
// .newInstance().getXFire());
//
// IService srvc = (IService) factory.create(srvcModel, Constants.CONNECT_URL);
// return srvc;
ProtocolSocketFactory easy = new EasySSLProtocolSocketFactory();
Protocol protocol = new Protocol(HTTP_TYPE, easy, PORT);
Protocol.registerProtocol(HTTP_TYPE, protocol);
Service serviceModel = new ObjectServiceFactory().create(IService.class,
SERVICE_NAME, SERVICE_NAMESPACE, null);
IService service = (IService) new XFireProxyFactory().create(serviceModel, SERVICE_URL);
Client client = ((XFireProxy)Proxy.getInvocationHandler(service)).getClient();
client.addOutHandler(new DOMOutHandler());
client.setProperty(CommonsHttpMessageSender.GZIP_ENABLED, Boolean.FALSE);
client.setProperty(CommonsHttpMessageSender.DISABLE_EXPECT_CONTINUE, "1");
client.setProperty(CommonsHttpMessageSender.HTTP_TIMEOUT, "0");
return service;
}
public static int active(String licenseId) throws Exception{
IService srvc = ServiceUtil.getService();
byte[] serverPublicKey = srvc.getServerPublicKey();
IKeyGenerator gen = new KeyGeneratorImpl();
byte[] k = gen.generateKey(licenseId, serverPublicKey);
Encrypt en = ProtectionFactory.getEncrypt();
String str = srvc.activeLicense(StringUtils.toHexString(k), en.getPublicKey());
byte[] b = StringUtils.toBytes(str);
b = en.decrypt(en.getPrivateKey(), b);
// System.out.println(new String(b));
if (Constants.RETURN_INVALIDLICENSE.equals(new String(b))) {
return Constants.RETURN_INVALIDLICENSE_INT;
} else if (Constants.RETURN_INVALIDBUNDLE.equals(new String(b))) {
return Constants.RETURN_INVALIDBUNDLE_INT;
} else if (Constants.RETURN_DBEXCEPTION.equals(new String(b))) {
return Constants.RETURN_DBEXCEPTION_INT;
} else if (Constants.RETURN_MUTILTEMPBUNDLE.equals(new String(b))) {
return Constants.RETURN_MUTILTEMPBUNDLE_INT;
} else if (Constants.RETURN_EXPIREDLICENSE.equals(new String(b))) {
return Constants.RETURN_EXPIREDLICENSE_INT;
} else {
FileUtils.writeFile(b, ProtectionFactory.getFileName(1, Constants.PRODUCTID));
FileUtils.writeFile(InstallKeyEncrypt.encrypt(gen.getInstallKey().getBytes()), ProtectionFactory.getFileName(2, 89));
if (FileUtils.isExsit()) {
return Constants.ACTIVE_OK_INT;
} else {
return Constants.RETURN_DBEXCEPTION_INT;
}
}
}
public static int check(String info, byte[] b) throws Exception {
if (info == null) {
LicenseReader reader = new LicenseReader(Constants.PRODUCTID);
info = reader.getLicenseInfo();
}
if (info == null) {
return Constants.STATE_INVALID;
}
String[] arrInfo = getStrFromInfo(info);
String strKeyCode = arrInfo[0];
// String strMacCode = arrInfo[1];
String strInstallCode = arrInfo[2];
if (b == null) {
b = FileUtils.readFile(ProtectionFactory.getFileName(2, Constants.PRODUCTID));
try {
b = InstallKeyEncrypt.decrypt(b);
if (!strInstallCode.equals(new String(b))) {
return Constants.STATE_INVALID;
}
} catch (Exception e) {
e.printStackTrace();
return Constants.STATE_INVALID;
}
}
if (b == null) {
return Constants.STATE_INVALID;
}
IService srvc = ServiceUtil.getService();
byte[] serverPublicKey = srvc.getServerPublicKey();
IKeyGenerator gen = new KeyGeneratorImpl();
byte[] k = gen.generateKey(strKeyCode, strInstallCode, serverPublicKey);
Encrypt en = ProtectionFactory.getEncrypt();
String str = srvc.checkLicense(StringUtils.toHexString(k), en.getPublicKey());
b = StringUtils.toBytes(str);
b = en.decrypt(en.getPrivateKey(), b);
info = new String(b);
if (Constants.RETURN_CHECKSUCESS.equals(info)) {
return Constants.STATE_VALID;
} else if (Constants.RETURN_EXPIREDLICENSE.equals(info)) {
return Constants.STATE_EXPIRED;
} else {
return Constants.STATE_INVALID;
}
}
public static int cancel() throws Exception {
LicenseReader reader = new LicenseReader(Constants.PRODUCTID);
String info = reader.getLicenseInfo();
if (info == null) {
return Constants.LOGOUT_FAIL;
}
IService srvc = ServiceUtil.getService();
byte[] serverPublicKey = srvc.getServerPublicKey();
Encrypt en = ProtectionFactory.getEncrypt();
String str = srvc.logoutLicense(StringUtils.toHexString(en.encrypt(serverPublicKey, info.getBytes())), en.getPublicKey());
byte[] b = StringUtils.toBytes(str);
b = en.decrypt(en.getPrivateKey(), b);
info = new String(b);
if (Constants.RETURN_LOGOUTSUCESS.equals(info)) {
return FileUtils.removeFile() ? Constants.LOGOUT_SUCCESS : Constants.LOGOUT_FAIL;
} else if (Constants.RETURN_INVALIDLICENSE.equals(info)) {
return FileUtils.removeFile() ? Constants.LOGOUT_SUCCESS : Constants.LOGOUT_FAIL;
} else {
return Constants.LOGOUT_FAIL;
}
}
private static String[] getStrFromInfo(String info) {
return info.split(Constants.SEPARATOR);
}
public static String getTempEndDate(String key) throws Exception {
if (key == null) {
return null;
}
IService srvc = ServiceUtil.getService();
byte[] serverPublicKey = srvc.getServerPublicKey();
Encrypt en = ProtectionFactory.getEncrypt();
String str = srvc.getTempEndDate(StringUtils.toHexString(en.encrypt(serverPublicKey, key.getBytes())), en.getPublicKey());
byte[] b = StringUtils.toBytes(str);
b = en.decrypt(en.getPrivateKey(), b);
key = new String(b);
if (Constants.RETURN_NULLTEMPENDDATE.equals(key)) {
return null;
} else {
return key;
}
}
}
| 7,225 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
Constants.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/test/net.heartsome.license.test/src/net/heartsome/license/constants/Constants.java | package net.heartsome.license.constants;
public class Constants {
// 信息的分隔符，和ws服务器的分隔符保持一致，两处需要同时修改。net.heartsome.r8.webservice.utils.Constants
public final static String SEPARATOR = "#&";
public final static String RETURN_INVALIDLICENSE = "It is a invalid License";
public final static int RETURN_INVALIDLICENSE_INT = 1;
public final static String RETURN_INVALIDBUNDLE = "It is a invalid Bundle License";
public final static int RETURN_INVALIDBUNDLE_INT = 2;
public final static String RETURN_DBEXCEPTION = "Update database exception";
public final static int RETURN_DBEXCEPTION_INT = 3;
public final static int ACTIVE_OK_INT = 4;
public final static String RETURN_MUTILTEMPBUNDLE = "Mutil Active Trial License";
public final static int RETURN_MUTILTEMPBUNDLE_INT = 5;
public final static String RETURN_EXPIREDLICENSE = "Your license has expired";
public final static int RETURN_EXPIREDLICENSE_INT = 6;
public final static String RETURN_MACCODEERR = "MacCode is invalid";
public final static String RETURN_CHECKSUCESS = "Check is Sucess";
public final static int CANCEL = -1;
public final static int STATE_FILE_NOT_EXSIT = 0;
public final static int STATE_NOT_ACTIVATED = 1;
public final static int STATE_VALID = 2;
public final static int STATE_INVALID = 3;
public final static int STATE_EXPIRED = 4;
public final static int STATE_UNCONNECT = 5;
public final static String RETURN_LOGOUTSUCESS = "Logout is sucess";
public final static int LOGOUT_SUCCESS = 1;
public final static int LOGOUT_FAIL = 2;
public final static int PRODUCTID = 89;
public final static String TYPE_TMEP = "0";
public final static String TYPE_BUSINESS = "1";
public final static String CONNECT_URL = "http://192.168.0.191:8080/r8/services/licenseManager";
public final static String RETURN_NULLTEMPENDDATE = "TempEndDate is null";
}
| 1,921 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
Mif2XliffTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/testSrc/net/heartsome/cat/converter/mif/test/Mif2XliffTest.java | package net.heartsome.cat.converter.mif.test;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.util.HashMap;
import java.util.Map;
import net.heartsome.cat.converter.Converter;
import net.heartsome.cat.converter.ConverterException;
import net.heartsome.cat.converter.mif.Mif2Xliff;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
public class Mif2XliffTest {
public static Mif2Xliff converter = new Mif2Xliff();
private static String srcFile = "rc/Test.mif";
private static String xlfFile = "rc/Test.mif.xlf";
private static String sklFile = "rc/Test.mif.skl";
@Before
public void setUp(){
File skl = new File(sklFile);
if(skl.exists()){
skl.delete();
}
File xlf = new File(xlfFile);
if(xlf.exists()){
xlf.delete();
}
}
@Test(expected = ConverterException.class)
public void testConvertMissingINI() throws ConverterException {
Map<String, String> args = new HashMap<String, String>();
args.put(Converter.ATTR_SOURCE_FILE, srcFile); //$NON-NLS-1$
args.put(Converter.ATTR_XLIFF_FILE, xlfFile); //$NON-NLS-1$
args.put(Converter.ATTR_SKELETON_FILE, sklFile); //$NON-NLS-1$
args.put(Converter.ATTR_SOURCE_LANGUAGE, "en-US"); //$NON-NLS-1$
args.put(Converter.ATTR_SOURCE_ENCODING, "UTF-8"); //$NON-NLS-1$
Map<String, String> result = converter.convert(args, null);
String xliff = result.get(Converter.ATTR_XLIFF_FILE);
assertNotNull(xliff);
File xlfFile = new File(xliff);
assertNotNull(xlfFile);
assertTrue(xlfFile.exists());
}
@AfterClass
public static void testConvert() throws ConverterException {
String rootFolder = "/data/john/Workspaces/CAT/HSTS7/";
Map<String, String> args = new HashMap<String, String>();
args.put(Converter.ATTR_SOURCE_FILE, srcFile); //$NON-NLS-1$
args.put(Converter.ATTR_XLIFF_FILE, xlfFile); //$NON-NLS-1$
args.put(Converter.ATTR_SKELETON_FILE, sklFile); //$NON-NLS-1$
args.put(Converter.ATTR_SOURCE_LANGUAGE, "en-US"); //$NON-NLS-1$
args.put(Converter.ATTR_SOURCE_ENCODING, "UTF-8"); //$NON-NLS-1$
args.put(Converter.ATTR_INI_FILE, rootFolder + "ini/init_mif.xml");
Map<String, String> result = converter.convert(args, null);
String xliff = result.get(Converter.ATTR_XLIFF_FILE);
assertNotNull(xliff);
File xlfFile = new File(xliff);
assertNotNull(xlfFile);
assertTrue(xlfFile.exists());
}
}
| 2,418 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
Xliff2MifTest.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/testSrc/net/heartsome/cat/converter/mif/test/Xliff2MifTest.java | package net.heartsome.cat.converter.mif.test;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.util.HashMap;
import java.util.Map;
import net.heartsome.cat.converter.Converter;
import net.heartsome.cat.converter.ConverterException;
import net.heartsome.cat.converter.mif.Xliff2Mif;
import org.junit.Before;
import org.junit.Test;
public class Xliff2MifTest {
public static Xliff2Mif converter = new Xliff2Mif();
private static String tgtFile = "rc/Test_zh-CN.mif";
private static String xlfFile = "rc/Test.mif.xlf";
private static String sklFile = "rc/Test.mif.skl";
@Before
public void setUp() {
File tgt = new File(tgtFile);
if (tgt.exists()) {
tgt.delete();
}
}
@Test
public void testConvert() throws ConverterException {
String rootFolder = "/data/john/Workspaces/CAT/HSTS7/";
Map<String, String> args = new HashMap<String, String>();
args.put(Converter.ATTR_TARGET_FILE, tgtFile); //$NON-NLS-1$
args.put(Converter.ATTR_XLIFF_FILE, xlfFile); //$NON-NLS-1$
args.put(Converter.ATTR_SKELETON_FILE, sklFile); //$NON-NLS-1$
args.put(Converter.ATTR_CATALOGUE, rootFolder
+ "catalogue/catalogue.xml");
args.put(Converter.ATTR_INI_FILE, rootFolder + "ini/init_mif.xml");
Map<String, String> result = converter.convert(args, null);
String target = result.get(Converter.ATTR_TARGET_FILE);
assertNotNull(target);
File tgtFile = new File(target);
assertNotNull(tgtFile);
assertTrue(tgtFile.exists());
}
}
| 1,530 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
Activator.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/Activator.java | /**
* Activator.java
*
* Version information :
*
* Date:Jan 14, 2010
*
* Copyright notice :
*/
package net.heartsome.cat.converter.mif;
import java.util.Properties;
import net.heartsome.cat.converter.Converter;
import net.heartsome.cat.converter.util.ConverterRegister;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
/**
* The activator class controls the plug-in life cycle.
*/
public class Activator extends AbstractUIPlugin implements BundleActivator {
// The plug-in ID
/** The Constant PLUGIN_ID. */
public static final String PLUGIN_ID = "net.heartsome.cat.converter.MIF";
// The shared instance
/** The plugin. */
private static Activator plugin;
/** The mif2 xliff sr. */
@SuppressWarnings("rawtypes")
private ServiceRegistration mif2XliffSR;
/** The xliff2 mif sr. */
@SuppressWarnings("rawtypes")
private ServiceRegistration xliff2MifSR;
/**
* The constructor.
*/
public Activator() {
}
/**
* (non-Javadoc)
* @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext)
* @param context
* @throws Exception
*/
public void start(BundleContext context) throws Exception {
super.start(context);
plugin = this;
// register the converter services
Converter mif2Xliff = new Mif2Xliff();
Properties properties = new Properties();
properties.put(Converter.ATTR_NAME, Mif2Xliff.NAME_VALUE);
properties.put(Converter.ATTR_TYPE, Mif2Xliff.TYPE_VALUE);
properties.put(Converter.ATTR_TYPE_NAME, Mif2Xliff.TYPE_NAME_VALUE);
mif2XliffSR = ConverterRegister.registerPositiveConverter(context, mif2Xliff, properties);
Converter xliff2Mif = new Xliff2Mif();
properties = new Properties();
properties.put(Converter.ATTR_NAME, Xliff2Mif.NAME_VALUE);
properties.put(Converter.ATTR_TYPE, Xliff2Mif.TYPE_VALUE);
properties.put(Converter.ATTR_TYPE_NAME, Xliff2Mif.TYPE_NAME_VALUE);
xliff2MifSR = ConverterRegister.registerReverseConverter(context, xliff2Mif, properties);
}
/**
* (non-Javadoc)
* @see org.osgi.framework.BundleActivator#stop(org.osgi.framework.BundleContext)
* @param context
* @throws Exception
*/
public void stop(BundleContext context) throws Exception {
if (mif2XliffSR != null) {
mif2XliffSR.unregister();
}
if (xliff2MifSR != null) {
xliff2MifSR.unregister();
}
plugin = null;
super.stop(context);
}
/**
* Returns the shared instance.
* @return the shared instance
*/
public static Activator getDefault() {
return plugin;
}
public static ImageDescriptor getImageDescriptor(String path) {
return imageDescriptorFromPlugin(PLUGIN_ID, path);
}
}
| 2,784 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
Xliff2Mif.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/Xliff2Mif.java | /**
* Xliff2Mif.java
*
* Version information :
*
* Date:Jan 14, 2010
*
* Copyright notice :
*/
package net.heartsome.cat.converter.mif;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.parsers.ParserConfigurationException;
import net.heartsome.cat.converter.Converter;
import net.heartsome.cat.converter.ConverterException;
import net.heartsome.cat.converter.mif.resource.Messages;
import net.heartsome.cat.converter.util.CalculateProcessedBytes;
import net.heartsome.cat.converter.util.ConverterUtils;
import net.heartsome.cat.converter.util.Progress;
import net.heartsome.cat.converter.util.ReverseConversionInfoLogRecord;
import net.heartsome.xml.Catalogue;
import net.heartsome.xml.Document;
import net.heartsome.xml.Element;
import net.heartsome.xml.SAXBuilder;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;
/**
* The Class Xliff2Mif.
* @author John Zhu
*/
public class Xliff2Mif implements Converter {
/** The Constant TYPE_VALUE. */
public static final String TYPE_VALUE = "mif";
/** The Constant TYPE_NAME_VALUE. */
public static final String TYPE_NAME_VALUE = Messages.getString("mif.TYPE_NAME_VALUE");
/** The Constant NAME_VALUE. */
public static final String NAME_VALUE = "XLIFF to MIF Conveter";
/**
* (non-Javadoc)
* @see net.heartsome.cat.converter.Converter#convert(java.util.Map, org.eclipse.core.runtime.IProgressMonitor)
* @param args
* @param monitor
* @return
* @throws ConverterException
*/
public Map<String, String> convert(Map<String, String> args, IProgressMonitor monitor) throws ConverterException {
Xliff2MifImpl converter = new Xliff2MifImpl();
String iniDir = args.get(Converter.ATTR_INIDIR);
String iniFile = iniDir + System.getProperty("file.separator") + "init_mif.xml";
args.put(Converter.ATTR_INI_FILE, iniFile);
return converter.run(args, monitor);
}
/**
* (non-Javadoc)
* @see net.heartsome.cat.converter.Converter#getName()
* @return
*/
public String getName() {
return NAME_VALUE;
}
/**
* (non-Javadoc)
* @see net.heartsome.cat.converter.Converter#getType()
* @return
*/
public String getType() {
return TYPE_VALUE;
}
/**
* (non-Javadoc)
* @see net.heartsome.cat.converter.Converter#getTypeName()
* @return
*/
public String getTypeName() {
return TYPE_NAME_VALUE;
}
/**
* The Class Xliff2MifImpl.
* @author John Zhu
* @version
* @since JDK1.6
*/
class Xliff2MifImpl {
private static final String UTF_8 = "UTF-8";
/** The input. */
private InputStreamReader input;
/** The buffer. */
private BufferedReader buffer;
/** The skl file. */
private String sklFile;
/** The xliff file. */
private String xliffFile;
/** The line. */
private String line;
/** The segments. */
private Hashtable<String, Element> segments;
/** The output. */
private FileOutputStream output;
// /** The charmap. */
// private Hashtable<String, String> charmap;
/** The catalogue. */
private String catalogue;
/** The ini file. */
private String iniFile;
// 计算替换进度的对象
private CalculateProcessedBytes cpb;
// 替换过程的进度监视器
private IProgressMonitor replaceMonitor;
// skeleton 文件编码
private String encoding;
/**
* This method receives a Hashtable that must contain the following data: xliff: String with the name of the
* XLIFF file to convert to MIF backfile: String with the name of the MIF file to generate skeleton: String with
* the name of the skeleton to use at reverse conversion tgtLanguage: String with the language code of the MIF
* file.
* @param monitor
* the monitor
* @param params
* the params
* @return the map< string, string>
* @throws ConverterException
* the converter exception
*/
public Map<String, String> run(Map<String, String> params, IProgressMonitor monitor) throws ConverterException {
monitor = Progress.getMonitor(monitor);
ReverseConversionInfoLogRecord infoLogger = ConverterUtils.getReverseConversionInfoLogRecord();
infoLogger.startConversion();
Map<String, String> result = new HashMap<String, String>();
sklFile = params.get(Converter.ATTR_SKELETON_FILE);
xliffFile = params.get(Converter.ATTR_XLIFF_FILE);
catalogue = params.get(Converter.ATTR_CATALOGUE);
iniFile = params.get(Converter.ATTR_INI_FILE);
String outputFile = params.get(Converter.ATTR_TARGET_FILE);
encoding = params.get(Converter.ATTR_SOURCE_ENCODING);
// String attrIsPreviewMode = params.get(Converter.ATTR_IS_PREVIEW_MODE);
/* 是否为预览翻译模式 */
// boolean isPreviewMode = attrIsPreviewMode != null && attrIsPreviewMode.equals(Converter.TRUE);
try {
infoLogger.logConversionFileInfo(catalogue, iniFile, xliffFile, sklFile);
// 把转换过程任务分为三大部分 10 任务，其中加载 xliff 文件占 3，加载 ini 文件占 3，替换过程占 4。
monitor.beginTask(Messages.getString("mif.Xliff2Mif.task1"), 10);
monitor.subTask(Messages.getString("mif.Xliff2Mif.task2"));
infoLogger.startLoadingXliffFile();
output = new FileOutputStream(outputFile);
loadSegments();
infoLogger.endLoadingXliffFile();
monitor.worked(3);
// 是否取消操作
if (monitor.isCanceled()) {
throw new OperationCanceledException(Messages.getString("preference.cancel"));
}
monitor.subTask(Messages.getString("mif.Xliff2Mif.task3"));
infoLogger.startLoadingIniFile();
// loadCharMap();
infoLogger.endLoadingIniFile();
monitor.worked(3);
// 是否取消操作
if (monitor.isCanceled()) {
throw new OperationCanceledException(Messages.getString("preference.cancel"));
}
try {
infoLogger.startReplacingSegmentSymbol();
cpb = ConverterUtils.getCalculateProcessedBytes(sklFile);
replaceMonitor = Progress.getSubMonitor(monitor, 4);
replaceMonitor.beginTask(Messages.getString("mif.Xliff2Mif.task4"), cpb.getTotalTask());
input = new InputStreamReader(new FileInputStream(sklFile), UTF_8); //$NON-NLS-1$
buffer = new BufferedReader(input);
line = buffer.readLine();
Pattern pattern = Pattern.compile("(?<=%%%)[0-9]+(?=%%%)");
while (line != null) {
line = line + "\n";
Matcher mat = pattern.matcher(line);
if (mat.find()) {
do {
String code = line.substring(mat.start(), mat.end());
Element segment = segments.get(code);
if (segment != null) {
Element target = segment.getChild("target");
Element source = segment.getChild("source");
if (line.toLowerCase().indexOf("mtext") != -1) {
if (target != null) {
String tgtStr = commonProcess(target);
if (!"".equals(tgtStr.trim())) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
// process target
line = line.replace("%%%" + code + "%%%", tgtStr);
writeString(line, true, code);
} else {
// process source
line = line.replace("%%%" + code + "%%%", commonProcess(source));
writeString(line, true, code);
}
} else {
// process source
line = line.replace("%%%" + code + "%%%", commonProcess(source));
writeString(line, true, code);
}
} else {
if (target != null) {
String tgtStr = process(target, code);
if (!"".equals(tgtStr.trim())) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
// process target
line = line.replace("%%%" + code + "%%%", tgtStr);
writeString(line, true, code);
} else {
// process source
line = line.replace("%%%" + code + "%%%", process(source, code));
writeString(line, true, code);
}
} else {
// process source
line = line.replace("%%%" + code + "%%%", process(source, code));
writeString(line, true, code);
}
}
} else {
ConverterUtils.throwConverterException(Activator.PLUGIN_ID,
MessageFormat.format(Messages.getString("mif.Xliff2Mif.msg1"), code));
}
} while (mat.find());
} else {
// non translatable portion
writeString(line);
}
line = buffer.readLine();
}
} finally {
replaceMonitor.done();
}
infoLogger.endReplacingSegmentSymbol();
output.close();
result.put(Converter.ATTR_TARGET_FILE, outputFile);
infoLogger.endConversion();
} catch (OperationCanceledException e) {
throw e;
} catch (Exception e) {
if (Converter.DEBUG_MODE) {
e.printStackTrace();
}
ConverterUtils
.throwConverterException(Activator.PLUGIN_ID, Messages.getString("mif.Xliff2Mif.msg2"), e);
} finally {
monitor.done();
}
return result;
}
/**
* Convert the escape character '\>' '\q' '\Q' '\\'
* @param c
* @return ;
*/
private String cleanString(String s) {
int control = s.indexOf("\\");
while (control != -1) {
int t = control + 1;
if (t < s.length() - 1 && s.charAt(t) != '>' && s.charAt(t) != '\\' && s.charAt(t) != 'x') {
s = s.substring(0, control) + "\\\\" + s.substring(control + 1);
}
if (control < s.length()) {
control++;
}
control = s.indexOf("\\", control + 1);
}
s = s.replace("`", "\\Q");
s = s.replace("'", "\\q");
s = s.replace("\u0009", "\\t");
return s;
}
/*
* /** Load char map.
*
* @throws SAXException the SAX exception
*
* @throws IOException Signals that an I/O exception has occurred.
*//*
* private void loadCharMap() throws SAXException, IOException { SAXBuilder cbuilder = new SAXBuilder();
* Document cdoc = cbuilder.build(iniFile); charmap = new Hashtable<String, String>(); Element croot =
* cdoc.getRootElement(); List<Element> codes = croot.getChildren("char"); //$NON-NLS-1$ Iterator<Element>
* it = codes.iterator(); while (it.hasNext()) { Element e = it.next(); charmap.put(e.getText(),
* e.getAttributeValue("code")); //$NON-NLS-1$ e = null; } it = null; codes = null; cdoc = null; cbuilder =
* null; }
*/
/**
* Process.
* @param e
* the e
* @throws IOException
* Signals that an I/O exception has occurred.
*/
private String process(Element e, String segmentSymbolCode) throws IOException {
String result = ""; //$NON-NLS-1$
List<Node> content = e.getContent();
Iterator<Node> i = content.iterator();
while (i.hasNext()) {
Node n = i.next();
switch (n.getNodeType()) {
case Node.TEXT_NODE:
result += "<String `" + cleanString(n.getNodeValue()) + "'>"; //$NON-NLS-1$ //$NON-NLS-2$
break;
case Node.ELEMENT_NODE:
Element el = new Element(n);
String r = "";
if (el.getName().equals("ph")) { //$NON-NLS-1$
String c = el.getText();
r = c;
int sos = c.indexOf("%%%");
while (sos != -1) {
sos += 3;
int eos = c.indexOf("%%%", sos);
String code = c.substring(sos, eos);
eos += 3;
Element segment = segments.get(code);
if (segment != null) {
Element target = segment.getChild("target");
Element source = segment.getChild("source");
String t = "";
if (target != null) {
t = commonProcess(target);
if (t.length() == 0) {
t = commonProcess(source);
}
} else {
t = commonProcess(source);
}
r = r.replace("%%%" + code + "%%%", t);
}
sos = c.indexOf("%%%", eos);
}
result += r; //$NON-NLS-1$
}
break;
default:
break;
}
}
i = null;
content = null;
return result;
}
private String commonProcess(Element e) throws IOException {
String result = ""; //$NON-NLS-1$
List<Node> content = e.getContent();
Iterator<Node> i = content.iterator();
while (i.hasNext()) {
Node n = i.next();
switch (n.getNodeType()) {
case Node.TEXT_NODE:
result += cleanString(n.getNodeValue());
break;
case Node.ELEMENT_NODE:
Element el = new Element(n);
if (el.getName().equals("ph")) { //$NON-NLS-1$
result += el.getText(); //$NON-NLS-1$
}
break;
default:
break;
}
}
i = null;
content = null;
return result;
}
/**
* Load segments.
* @throws SAXException
* the SAX exception
* @throws IOException
* Signals that an I/O exception has occurred.
* @throws ParserConfigurationException
* the parser configuration exception
*/
private void loadSegments() throws SAXException, IOException, ParserConfigurationException {
SAXBuilder builder = new SAXBuilder();
builder.setEntityResolver(new Catalogue(catalogue));
Document doc = builder.build(xliffFile);
Element root = doc.getRootElement();
Element body = root.getChild("file").getChild("body"); //$NON-NLS-1$ //$NON-NLS-2$
List<Element> units = body.getChildren("trans-unit"); //$NON-NLS-1$
Iterator<Element> i = units.iterator();
segments = new Hashtable<String, Element>();
while (i.hasNext()) {
Element unit = i.next();
segments.put(unit.getAttributeValue("id"), unit); //$NON-NLS-1$
}
}
/**
* Write string.
* @param string
* the string
* @throws IOException
* Signals that an I/O exception has occurred.
*/
private void writeString(String string) throws IOException {
writeString(string, false, null);
}
/**
* Write string.
* @param string
* the string
* @param isSegment
* 标识当前所写内容，ture 标识当前所写内容为 segment，false 标识当前所定内容为原骨架文件中的内容。
* @param replaceCode
* skeleton 文件中的segment 标识符
* @throws IOException
* Signals that an I/O exception has occurred.
*/
private void writeString(String string, boolean isSegment, String replaceCode) throws IOException {
byte[] bytes = string.getBytes(encoding);
output.write(bytes);
// 是否取消操作
if (replaceMonitor.isCanceled()) {
throw new OperationCanceledException(Messages.getString("preference.cancel"));
}
// 在计算已处理的字节时，需要用 skeleton 文件的源编码进行解码
if (!isSegment) {
cpb.calculateProcessed(replaceMonitor, string, UTF_8);
} else {
replaceCode = "%%%" + replaceCode + "%%%";
cpb.calculateProcessed(replaceMonitor, replaceCode, UTF_8);
}
}
}
}
| 15,126 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
Mif2Xliff.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/Mif2Xliff.java | /**
* Mif2Xliff.java
*
* Version information :
*
* Date:Jan 14, 2010
*
* Copyright notice :
*/
package net.heartsome.cat.converter.mif;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import net.heartsome.cat.converter.Converter;
import net.heartsome.cat.converter.ConverterException;
import net.heartsome.cat.converter.StringSegmenter;
import net.heartsome.cat.converter.mif.common.MifParseException;
import net.heartsome.cat.converter.mif.common.UnSuportedFileExcetption;
import net.heartsome.cat.converter.mif.parser.XliffReader;
import net.heartsome.cat.converter.mif.preference.Constants;
import net.heartsome.cat.converter.mif.resource.Messages;
import net.heartsome.cat.converter.util.ConverterUtils;
import net.heartsome.util.TextUtil;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.preference.IPreferenceStore;
/**
* The Class Mif2Xliff.
* @author John Zhu
*/
public class Mif2Xliff implements Converter {
/** The Constant TYPE_VALUE. */
public static final String TYPE_VALUE = "mif";
/** The Constant TYPE_NAME_VALUE. */
public static final String TYPE_NAME_VALUE = Messages.getString("mif.TYPE_NAME_VALUE");
/** The Constant NAME_VALUE. */
public static final String NAME_VALUE = "MIF to XLIFF Conveter";
/**
* (non-Javadoc)
* @see net.heartsome.cat.converter.Converter#convert(java.util.Map, org.eclipse.core.runtime.IProgressMonitor)
* @param args
* @param monitor
* @return
* @throws ConverterException
*/
public Map<String, String> convert(Map<String, String> args, IProgressMonitor monitor) throws ConverterException {
Mif2XliffImpl converter = new Mif2XliffImpl();
// String iniDir = args.get(Converter.ATTR_INIDIR);
// String iniFile = iniDir + System.getProperty("file.separator") + "init_mif.xml";
// args.put(Converter.ATTR_INI_FILE, iniFile);
return converter.run(args, monitor);
}
/**
* (non-Javadoc)
* @see net.heartsome.cat.converter.Converter#getName()
* @return
*/
public String getName() {
return NAME_VALUE;
}
/**
* (non-Javadoc)
* @see net.heartsome.cat.converter.Converter#getType()
* @return
*/
public String getType() {
return TYPE_VALUE;
}
/**
* (non-Javadoc)
* @see net.heartsome.cat.converter.Converter#getTypeName()
* @return
*/
public String getTypeName() {
return TYPE_NAME_VALUE;
}
/**
* The Class Mif2XliffImpl.
* @author John Zhu
* @version
* @since JDK1.6
*/
class Mif2XliffImpl {
public Map<String, String> run(Map<String, String> params, IProgressMonitor monitor) throws ConverterException {
Map<String, String> result = new HashMap<String, String>();
if (monitor == null) {
monitor = new NullProgressMonitor();
}
String inputFile = params.get(Converter.ATTR_SOURCE_FILE);
String xliffFile = params.get(Converter.ATTR_XLIFF_FILE);
String skeletonFile = params.get(Converter.ATTR_SKELETON_FILE);
String sourceLanguage = params.get(Converter.ATTR_SOURCE_LANGUAGE);
String encoding = params.get(Converter.ATTR_SOURCE_ENCODING);
// String iniFile = params.get(Converter.ATTR_INI_FILE);
// if (iniFile == null || "".equals(iniFile)) {
// ConverterUtils.throwConverterException(Activator.PLUGIN_ID, Messages.getString("mif.Mif2Xliff.msg1"));
// }
String catalogue = params.get(Converter.ATTR_CATALOGUE);
String initSegmenter = params.get(Converter.ATTR_SRX);
StringSegmenter segmenter = null;
try {
segmenter = new StringSegmenter(initSegmenter, sourceLanguage, catalogue);
} catch (Exception e) {
ConverterUtils.throwConverterException(Activator.PLUGIN_ID, Messages.getString("mif.mif2xliff.msg3") + e.getMessage(), e);
}
BufferedWriter xlfWriter = null;
BufferedWriter sklOs = null;
try {
monitor.beginTask(Messages.getString("mif.Mif2Xliff.task1"), 4);
xlfWriter = new BufferedWriter(new FileWriter(xliffFile));
// generation the header of xliff file
writeXliffHeader(xlfWriter, inputFile, sourceLanguage, skeletonFile, encoding);
monitor.worked(1);
monitor.setTaskName(Messages.getString("mif.Mif2Xliff.task2"));
XliffReader r = new XliffReader(inputFile, encoding, sourceLanguage, segmenter);
monitor.worked(1);
IPreferenceStore store = Activator.getDefault().getPreferenceStore();
r.readXliffFile(xlfWriter, /*iniFile*/null, !store.getBoolean(Constants.FRAMEMAKER_FILTER), new SubProgressMonitor(monitor, 1));
// generation the end of xliff file
writeXliffTail(xlfWriter);
sklOs = new BufferedWriter(new FileWriter(skeletonFile));
r.readSkeletonFile(sklOs, new SubProgressMonitor(monitor, 1));
} catch (IOException e) {
ConverterUtils.throwConverterException(Activator.PLUGIN_ID, Messages.getString("mif.Mif2Xliff.error1") + e.getMessage(), e);
} catch (MifParseException e) {
ConverterUtils.throwConverterException(Activator.PLUGIN_ID, Messages.getString("mif.Mif2Xliff.error2") + e.getMessage(), e);
} catch (UnSuportedFileExcetption e) {
ConverterUtils.throwConverterException(Activator.PLUGIN_ID, Messages.getString("mif.Mif2Xliff.error3") + e.getMessage(), e);
} finally {
try {
if (xlfWriter != null) {
xlfWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (sklOs != null) {
sklOs.close();
}
} catch (IOException e) {
e.printStackTrace();
}
monitor.done();
}
result.put(Converter.ATTR_XLIFF_FILE, xliffFile);
return result;
}
private void writeXliffHeader(BufferedWriter xlfWriter, String inputFile, String srcLang, String sklFile,
String encoding) throws IOException {
xlfWriter.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
xlfWriter.write("<xliff version=\"1.2\" xmlns=\"urn:oasis:names:tc:xliff:document:1.2\" "
+ "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " + "xmlns:hs=\""
+ Converter.HSNAMESPACE + "\" "
+ "xsi:schemaLocation=\"urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd "
+ Converter.HSSCHEMALOCATION + "\">\n");
xlfWriter.write("<file original=\"" + TextUtil.cleanString(inputFile) + "\" source-language=\"" + srcLang + "\" datatype=\""
+ TYPE_VALUE + "\">\n");
xlfWriter.write("<header>\n");
xlfWriter.write(" <skl>\n");
xlfWriter.write(" <external-file href=\"" + TextUtil.cleanString(sklFile) + "\"/>\n"); //$NON-NLS-2$ //$NON-NLS-3$
xlfWriter.write(" </skl>\n");
xlfWriter
.write(" <tool tool-id=\"" + Converter.QT_TOOLID_DEFAULT_VALUE + "\" tool-name=\"HSStudio\"/>\n"); //$NON-NLS-2$
xlfWriter.write(" <hs:prop-group name=\"encoding\"><hs:prop prop-type=\"encoding\">" + encoding
+ "</hs:prop></hs:prop-group>\n");
xlfWriter.write("</header>\n");
xlfWriter.write("<body>\n");
}
private void writeXliffTail(BufferedWriter xlfWriter) throws IOException {
xlfWriter.write("</body>\n");
xlfWriter.write("</file>\n");
xlfWriter.write("</xliff>");
}
}
} | 7,172 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ReaderUtil.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/common/ReaderUtil.java | package net.heartsome.cat.converter.mif.common;
public class ReaderUtil {
// /** The charmap. */
// private Hashtable<String, String> charmap;
public ReaderUtil(String iniFile) /* throws SAXException, IOException */{
// loadCharMap(iniFile);
}
public String cleanString(String s) {
int control = s.indexOf("&");
while (control != -1) {
s = s.substring(0, control) + "&" + s.substring(control + 1);
if (control < s.length()) {
control++;
}
control = s.indexOf("&", control);
}
control = s.indexOf("<");
while (control != -1) {
s = s.substring(0, control) + "<" + s.substring(control + 1);
if (control < s.length()) {
control++;
}
control = s.indexOf("<", control);
}
control = s.indexOf(">");
while (control != -1) {
s = s.substring(0, control) + ">" + s.substring(control + 1);
if (control < s.length()) {
control++;
}
control = s.indexOf(">", control);
}
s = s.replace("\\q", "'");
s = s.replace("\\Q", "`");
s = s.replace("\\\\", "\\");
// 以下代码注释，是因为nonstandard ASCII不做转义处理
// control = s.indexOf("\\x");
// while (control != -1) {
// String code = s.substring(control + 2, s.indexOf(" ", control));
//
// String character = "" + getCharValue(Integer.valueOf(code, 16).intValue());
// if (!character.equals("")) {
// s = s.substring(0, control) + character + s.substring(1 + s.indexOf(" ", control));
// }
// control++;
// control = s.indexOf("\\x", control);
// }
return s;
}
/**
* This method cleans the text that will be stored inside <ph>elements in the XLIFF file *.
* @param line
* the line
* @return the string
*/
public String cleanTag(String line) {
String s = line;
int control = s.indexOf("&");
while (control != -1) {
s = s.substring(0, control) + "&" + s.substring(control + 1);
if (control < s.length()) {
control++;
}
control = s.indexOf("&", control);
}
control = s.indexOf("<");
while (control != -1) {
s = s.substring(0, control) + "<" + s.substring(control + 1);
if (control < s.length()) {
control++;
}
control = s.indexOf("<", control);
}
control = s.indexOf(">");
while (control != -1) {
s = s.substring(0, control) + ">" + s.substring(control + 1);
if (control < s.length()) {
control++;
}
control = s.indexOf(">", control);
}
return s;
}
/*
* 此部分代码注释，是因为nonstandard ASCII不做转义处理 /** Load char map.
*
* @throws SAXException the SAX exception
*
* @throws IOException Signals that an I/O exception has occurred.
*
* @throws ParserConfigurationException
*//*
* private void loadCharMap(String iniFile) throws SAXException, IOException { SAXBuilder cbuilder = new
* SAXBuilder(); Document cdoc = cbuilder.build(iniFile); charmap = new Hashtable<String, String>(); Element
* croot = cdoc.getRootElement(); List<Element> codes = croot.getChildren("char"); //$NON-NLS-1$
* Iterator<Element> it = codes.iterator(); while (it.hasNext()) { Element e = it.next();
* charmap.put(e.getAttributeValue("code"), e.getText()); //$NON-NLS-1$ e = null; } it = null; codes = null;
* cdoc = null; cbuilder = null; }
*
* /** Gets the char value.
*
* @param value the value
*
* @return the char value
*//*
* private char getCharValue(int value) { switch (value) { case 0x04: return '\u0004'; case 0x05: return
* '\u0005'; case 0x08: return '\u0008'; case 0x09: return '\u0009'; case 0x0a: return '\u0010'; case 0x10:
* return '\u0016'; case 0x11: return '\u0017'; case 0x12: return '\u0018'; case 0x13: return '\u0019'; case
* 0x14: return '\u0020'; case 0x15: return '\u0021'; default: break; } if (value > 0x7f) { String key =
* "\\x" + Integer.toHexString(value); //$NON-NLS-1$ if (charmap.containsKey(key)) { String result =
* charmap.get(key); if (result.length() > 0) { return result.charAt(0); } result = null; } key = null; }
* return (char) value; }
*/
}
| 4,059 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
UnSuportedFileExcetption.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/common/UnSuportedFileExcetption.java | /**
* UnSuportedFileExcetption.java
*
* Version information :
*
* Date:2012-7-24
*
* Copyright notice :
* 本文件及其附带的相关文件包含机密信息，仅限瀚特盛科技有限公司指定的，与本项目有关的内部人员和客户联络人员查阅和使用。
* 如果您不是本保密声明中指定的收件者，请立即销毁本文件，禁止对本文件或根据本文件中的内容采取任何其他行动，
* 包括但不限于：泄露本文件中的信息、以任何方式制作本文件全部或部分内容之副本、将本文件或其相关副本提供给任何其他人。
*/
package net.heartsome.cat.converter.mif.common;
/**
* @author jason
* @version
* @since JDK1.6
*/
public class UnSuportedFileExcetption extends Exception {
/** serialVersionUID. */
private static final long serialVersionUID = 1L;
public UnSuportedFileExcetption() {
super();
}
public UnSuportedFileExcetption(String message) {
super(message);
}
}
| 1,001 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
MifParseException.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/common/MifParseException.java | package net.heartsome.cat.converter.mif.common;
public class MifParseException extends Exception {
/**
*
*/
private static final long serialVersionUID = 1L;
public MifParseException() {
super();
}
public MifParseException(String message) {
super("\n"+message);
}
}
| 301 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ConverterPreferenceInitializer.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/preference/ConverterPreferenceInitializer.java | package net.heartsome.cat.converter.mif.preference;
import net.heartsome.cat.converter.mif.Activator;
import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;
import org.eclipse.jface.preference.IPreferenceStore;
/**
* 设置首选项 Adobe FrameMaker 的默认值类
* @author peason
* @version
* @since JDK1.6
*/
public class ConverterPreferenceInitializer extends AbstractPreferenceInitializer {
@Override
public void initializeDefaultPreferences() {
IPreferenceStore store = Activator.getDefault().getPreferenceStore();
store.setDefault(Constants.FRAMEMAKER_FILTER, false);
}
}
| 621 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
FrameMakerPreferencePage.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/preference/FrameMakerPreferencePage.java | package net.heartsome.cat.converter.mif.preference;
import net.heartsome.cat.common.ui.HsImageLabel;
import net.heartsome.cat.converter.mif.Activator;
import net.heartsome.cat.converter.mif.resource.Messages;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
/**
* 首选项-->Adobe FrameMarker 页面
* @author peason
* @version
* @since JDK1.6
*/
public class FrameMakerPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {
private IPreferenceStore preferenceStore;
/** 母版内容复选框 */
private Button btnMaster;
public FrameMakerPreferencePage() {
setTitle(Messages.getString("preference.FrameMakerPreferencePage.title"));
setPreferenceStore(Activator.getDefault().getPreferenceStore());
preferenceStore = getPreferenceStore();
}
@Override
protected Control createContents(Composite parent) {
Composite tparent = new Composite(parent, SWT.NONE);
tparent.setLayout(new GridLayout());
tparent.setLayoutData(new GridData(GridData.FILL_BOTH));
Group groupCommon = new Group(tparent, SWT.NONE);
groupCommon.setLayout(new GridLayout());
groupCommon.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
groupCommon.setText(Messages.getString("preference.FrameMakerPreferencePage.groupCommon"));
HsImageLabel imageLabel = new HsImageLabel(
Messages.getString("preference.FrameMakerPreferencePage.imageLabel"),
Activator.getImageDescriptor(Constants.PREFERENCE_FRAMEMAKER_32));
Composite cmpCommon = imageLabel.createControl(groupCommon);
cmpCommon.setLayout(new GridLayout());
cmpCommon.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
btnMaster = new Button(cmpCommon, SWT.CHECK);
btnMaster.setText(Messages.getString("preference.FrameMakerPreferencePage.btnMaster"));
GridDataFactory.fillDefaults().applyTo(btnMaster);
imageLabel.computeSize();
btnMaster.setSelection(preferenceStore.getBoolean(Constants.FRAMEMAKER_FILTER));
return parent;
}
public void init(IWorkbench workbench) {
}
@Override
protected void performDefaults() {
btnMaster.setSelection(preferenceStore.getDefaultBoolean(Constants.FRAMEMAKER_FILTER));
}
@Override
public boolean performOk() {
preferenceStore.setValue(Constants.FRAMEMAKER_FILTER, btnMaster.getSelection());
return true;
}
}
| 2,738 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
Constants.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/preference/Constants.java | package net.heartsome.cat.converter.mif.preference;
/**
* 常量类
* @author peason
* @version
* @since JDK1.6
*/
public final class Constants {
/** 首选项-->Adobe FrameMarker 页面的提示信息图片 */
public static final String PREFERENCE_FRAMEMAKER_32 = "images/preference/framemaker_32.png";
public static final String FRAMEMAKER_FILTER = "net.heartsome.cat.convert.ui.preference.FrameMaker";
}
| 426 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
XliffReader.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/parser/XliffReader.java | package net.heartsome.cat.converter.mif.parser;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.EOFException;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Comparator;
import java.util.List;
import java.util.Stack;
import net.heartsome.cat.converter.StringSegmenter;
import net.heartsome.cat.converter.mif.bean.Frame;
import net.heartsome.cat.converter.mif.bean.Marker;
import net.heartsome.cat.converter.mif.bean.MifParseBuffer;
import net.heartsome.cat.converter.mif.bean.MifReaderBuffer;
import net.heartsome.cat.converter.mif.bean.Page;
import net.heartsome.cat.converter.mif.bean.Table;
import net.heartsome.cat.converter.mif.bean.TextFlow;
import net.heartsome.cat.converter.mif.bean.TextRect;
import net.heartsome.cat.converter.mif.common.MifParseException;
import net.heartsome.cat.converter.mif.common.ReaderUtil;
import net.heartsome.cat.converter.mif.common.UnSuportedFileExcetption;
import net.heartsome.cat.converter.mif.resource.Messages;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
public class XliffReader {
/** Current doc */
private char[] doc;
/** The MIF parse buffer */
private MifParseBuffer mpbf;
/** The MIF file reader buffer */
private MifReaderBuffer mrbf;
/** The XLiff TransUnit index counter */
private int xliffIdex;
/** The String Segementer */
private StringSegmenter strSger;
/** The doc start offset */
private int sos;
/** The doc end offset */
private int eos;
/** The temporary offset */
private int tempos;
private BufferedWriter xlfOs;
/** Source language code */
private String srcLang;
private MifReader r;
private EOFException eofExp;
/** The current character of doc */
private char ch;
private Stack<String> nameStack;
/** The Reader Util, provide the string common function */
private ReaderUtil rUtil;
private String mifEncoding;
/**
* The constructor of XLIFF reader, the reader response to generate XLIFF file by
* {@link #readXliffFile(BufferedWriter, String, boolean, IProgressMonitor)} method and generate skeleton file by
* {@link #readSkeletonFile(BufferedWriter, IProgressMonitor)} method <br>
* Notice : when create instance of this class, would load the MIF file and parse it by use the @param mifFile
* @param mifFile
* MIF file path
* @param encoding
* MIF file encoding
* @param sourceLanguage
* the language in MIF file
* @param strSger
* The string segementer, witch use the SRX to segment the paragraph of text
* @throws IOException
* @throws MifParseException
* @throws UnSuportedFileExcetption
*/
public XliffReader(String mifFile, String encoding, String sourceLanguage, StringSegmenter strSger)
throws IOException, MifParseException, UnSuportedFileExcetption {
loadFile(mifFile, encoding);
this.mifEncoding = encoding;
this.strSger = strSger;
this.srcLang = sourceLanguage;
this.xliffIdex = 1;
}
private void loadFile(String mifFile, String encoding) throws IOException, MifParseException,
UnSuportedFileExcetption {
MifParser parser = new MifParser();
parser.parseFile(mifFile, encoding);
this.doc = parser.doc;
this.mpbf = parser.mpbf;
this.sos = 0;
this.eos = doc.length;
this.tempos = 0;
this.mrbf = new MifReaderBuffer();
this.r = new MifReader();
this.eofExp = new EOFException("End of file");
this.nameStack = new Stack<String>();
}
/**
* After parse file, this method read the xliff file from the parse info
* @param xlfOs
* the xliff file out put stream
* @param iniFile
* the configure file of mif,witch define the ESC
* @param isReadMasterPage
* xliff contain the masterpage or not
* @param monitor
* the progress monitor
* @throws MifParseException
* @throws IOException
* ;
* @throws UnSuportedFileExcetption
*/
public void readXliffFile(BufferedWriter xlfOs, String iniFile, boolean isReadMasterPage, IProgressMonitor monitor)
throws MifParseException, IOException, UnSuportedFileExcetption {
if (monitor == null) {
monitor = new NullProgressMonitor();
}
rUtil = new ReaderUtil(iniFile);
File xf = File.createTempFile("xliftemp", ".temp");
// first read the index
List<Marker> markers = mpbf.getMarkers();
if (markers.size() > 0) {
File f = File.createTempFile("miftemp", ".tmp");
BufferedWriter tmpWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f),mifEncoding));
try {
this.xlfOs = new BufferedWriter(new FileWriter(xf));
// generate the xliff content to temporary file xf
for (Marker m : markers) {
outputSegmenet(rUtil.cleanString(m.getContent()), m.getOffset(), m.getEndOffset(), 1);
}
// generate temporary file ,the file had extracted index content and contains '%%%index%%%'
readSkeletonFile(tmpWriter, null);
} finally {
if (tmpWriter != null) {
tmpWriter.close();
}
if (this.xlfOs != null) {
this.xlfOs.close();
}
}
// reload the temporary file
loadFile(f.getAbsolutePath(), mifEncoding);
// after reload delete the temporary file
f.delete();
}
// second read the content
this.xlfOs = xlfOs;
List<Page> pages = mpbf.getPages();
monitor.setTaskName(Messages.getString("mif.Mif2Xliff.task3"));
if (pages.size() == 0) {
// no pages specified ,direct read the Para statement
monitor.beginTask(Messages.getString("mif.Mif2Xliff.task3"), 1);
monitor.worked(1);
readPara();
} else {
monitor.beginTask(Messages.getString("mif.Mif2Xliff.task3"), pages.size());
for (Page page : pages) {
String pageType = page.getPageType().toLowerCase();
if (pageType.equals("bodypage")) {
readPage(page);
} else if (pageType.indexOf("masterpage") != -1 && isReadMasterPage) {
readPage(page);
}
monitor.worked(1);
}
}
BufferedReader r = null;
try {
r = new BufferedReader(new FileReader(xf));
String line = r.readLine();
while (line != null) {
this.xlfOs.write(line + "\n");
line = r.readLine();
}
} finally {
if (r != null) {
r.close();
}
xf.delete();
}
monitor.done();
}
/**
* After parse file, this method read skeleton file from the parse info
* @param sklOs
* The skeleton file out put stream
* @param monitor
* the progress monitor
* @throws IOException
* ;
*/
public void readSkeletonFile(BufferedWriter sklOs, IProgressMonitor monitor) throws IOException {
if (monitor == null) {
monitor = new NullProgressMonitor();
}
List<Object[]> cbfs = mrbf.getBuffer(new Comparator<Object[]>() {
public int compare(Object[] o1, Object[] o2) {
Integer v1 = (Integer) o1[1];
int v2 = (Integer) o2[1];
return v1.compareTo(v2);
}
});
int off = 0;
int len = doc.length;
monitor.setTaskName(Messages.getString("mif.Mif2Xliff.task4"));
if (cbfs.size() == 0) {
monitor.beginTask(Messages.getString("mif.Mif2Xliff.task4"), 1);
sklOs.write(doc, off, len);
} else {
monitor.beginTask(Messages.getString("mif.Mif2Xliff.task4"), cbfs.size() + 1);
for (Object[] obj : cbfs) {
int index = (Integer) obj[0];
int start = (Integer) obj[1];
int end = (Integer) obj[2];
int segNum = (Integer) obj[3];
sklOs.write(doc, off, start - off);
off = end;
sklOs.write("%%%" + index + "%%%");
while (segNum > 1) {
sklOs.write("\n%%%" + ++index + "%%%");
segNum--;
}
monitor.worked(1);
}
sklOs.write(new String(doc, off, len - off).trim());
monitor.worked(1);
}
monitor.done();
}
private void readPage(Page page) throws MifParseException, IOException {
List<TextRect> trs = page.getTextRects();
readTextRect(trs);
}
private void readTextRect(List<TextRect> trs) throws MifParseException, IOException {
for (TextRect tr : trs) {
String id = tr.getId();
TextFlow tf = mpbf.getTextFlow(id);
if (tf == null) {
continue;
}
readTextFlow(tf);
}
}
private void readTextFlow(TextFlow tf) throws MifParseException, IOException {
sos = tf.getOffset();
eos = tf.getEndOffset();
int parasos = 0;
ch = r.getCharAfterIgnore();
while (true) {
switch (ch) {
case '<':
tempos = sos - 1;
String name = getStatmentName();
nameStack.push(name);
if (name.equals("para")) {
parasos = tempos;
}
break;
case '`':
getValue();
break;
case '>':
if(doc[sos -2] == '\\'){
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
name = nameStack.pop();
if (name.equals("para")) {
int tempEos = eos;
eos = sos;
sos = parasos;
// System.out.println(new String(doc,sos,eos -sos));
readPara();
eos = tempEos;
}
break;
default:
break;
}
if (sos == eos) {
return;
}
ch = r.getChar();
}
}
/**
* The sos and eos is the Para element start and end
* @throws MifParseException
* @throws IOException
*/
private void readPara() throws MifParseException, IOException {
ch = r.getCharAfterIgnore();
if (ch != '<') {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.statementError") + formatLineNumber());
}
int plsos = 0; // the first paraline start offset;
int plCounter = 0;
while (true) {
switch (ch) {
case '<':
tempos = sos - 1;
String name = getStatmentName();
nameStack.push(name);
if (name.equals("paraline")) {
// start ParaLine element
if (plsos == 0) {
plsos = tempos;
}
}
if (name.equals("incondition")) {
ch = r.getCharAfterIgnore();
if (ch != '`') {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.statementError")
+ formatLineNumber());
}
String val = getValue();
if (val.equalsIgnoreCase("FM8_TRACK_CHANGES_ADDED")
|| val.equalsIgnoreCase("FM8_TRACK_CHANGES_ADDED")) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.changeBarError"));
}
}
break;
case '`':
getValue();
break;
case '>':
if(doc[sos -2] == '\\'){
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
name = nameStack.pop();
if (name.equals("paraline")) {
plCounter++;
}
if (name.equals("para")) {
int tempEos = eos;
int tempsos = sos;
eos = sos - 1;
sos = plsos;
// System.out.println(new String(doc,sos,eos -sos));
readParalines(plCounter);
sos = tempsos;
eos = tempEos;
}
break;
default:
break;
}
if (sos == eos) {
return;
}
ch = r.getChar();
}
}
private void readParalines(int plNum) throws MifParseException, IOException {
ch = r.getCharAfterIgnore();
int strsos = 0; // string statement start offset
int streos = 0; // string statement end offset
int tagIdex = 1; // the index of tag
int tagsos = 0;
int tageos = 0;
int strCounter = 0; // the string statement counter,Count is greater
// than 1
// will segment the content
StringBuffer extraValBf = new StringBuffer();
// StringBuffer tagValBf = new StringBuffer();
while (true) {
switch (ch) {
case '<':
tempos = sos - 1;
String name = getStatmentName();
nameStack.push(name);
if (name.equals("paraline")) {
// flag = false;
tagsos = 0;
tageos = 0;
}
if (name.equals("string")) {
// start to extraction text content
ch = r.getCharAfterIgnore();
String text = getValue();
if (extraValBf.length() == 0) {
// the first of string statement
strsos = tempos;
} else {
tageos = tempos;
}
if (tagsos != 0 && tageos != 0 && tagsos != tageos) {
// System.out.println(formatLineNumber(tagsos) +" "+ formatLineNumber(tageos));
String tag = new String(doc, tagsos, tageos - tagsos);
if (tag.trim().length() != 0) {
extraValBf.append("<ph id=\"" + tagIdex++ + "\">");
extraValBf.append(rUtil.cleanTag(tag));
extraValBf.append("</ph>");
}
tagsos = 0;
tageos = 0;
}
extraValBf.append(rUtil.cleanString(text));
strCounter++;
}
if (name.equals("char")) {
String val = getContentEndBy('>');
if (val.equals("HardReturn") && extraValBf.length() != 0) {
outputSegmenet(extraValBf.toString(), strsos, streos, strCounter);
strsos = 0;
streos = 0;
extraValBf.delete(0, extraValBf.length());
tagsos = 0;
tageos = 0;
strCounter = 0;
}
}
if (name.equals("aframe")) {
String id = getContentEndBy('>');
if (id == null || id.length() == 0) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.statementError")
+ formatLineNumber());
}
Frame fm = mpbf.getFrame(id);
if (fm == null) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.noFrameFind")
+ formatLineNumber());
}
// save extract text
if (extraValBf.length() != 0) {
outputSegmenet(extraValBf.toString(), strsos, streos, strCounter);
strsos = 0;
streos = 0;
extraValBf.delete(0, extraValBf.length());
tagsos = 0;
tageos = 0;
strCounter = 0;
}
List<TextRect> trs = fm.getTextRects();
readTextRect(trs);
}
if (name.equals("atbl")) {
String id = getContentEndBy('>');
if (id == null || id.length() == 0) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.statementError")
+ formatLineNumber());
}
Table tbl = mpbf.getTable(id);
if (tbl == null) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.noTableFind")
+ formatLineNumber());
}
// save extract text
if (extraValBf.length() != 0) {
outputSegmenet(extraValBf.toString(), strsos, streos, strCounter);
strsos = 0;
streos = 0;
extraValBf.delete(0, extraValBf.length());
tagsos = 0;
tageos = 0;
strCounter = 0;
}
int tempsos = sos;
int tempeos = eos;
readTable(tbl);
sos = tempsos;
eos = tempeos;
}
break;
case '>':
if(doc[sos -2] == '\\'){
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
name = nameStack.pop();
if (name.equals("string")) {
// end of string statement
streos = sos;
tagsos = sos;
}
if (name.equals("paraline")) {
tageos = sos - 1;
plNum--;
if (tagsos != 0 && tageos != 0 && tagsos != tageos && plNum != 0) {
// when plNum == 0 is the last ParaLine
String tag = new String(doc, tagsos, tageos - tagsos);
if (tag.trim().length() != 0) {
extraValBf.append("<ph id=\"" + tagIdex++ + "\">");
extraValBf.append(rUtil.cleanTag(tag));
extraValBf.append("</ph>");
}
tagsos = 0;
tageos = 0;
}
}
default:
break;
}
if (sos == eos) {
if (extraValBf.length() != 0) {
outputSegmenet(extraValBf.toString(), strsos, streos, strCounter);
strsos = 0;
streos = 0;
extraValBf.delete(0, extraValBf.length());
tagsos = 0;
tageos = 0;
strCounter = 0;
}
return;
}
ch = r.getChar();
}
}
private void readTable(Table tbl) throws MifParseException, IOException {
sos = tbl.getOffset();
eos = tbl.getEndOffset();
int parasos = 0;
ch = r.getCharAfterIgnore();
while (true) {
switch (ch) {
case '<':
tempos = sos - 1;
String name = getStatmentName();
nameStack.push(name);
if (name.equals("para")) {
parasos = tempos;
}
break;
case '`':
getValue();
break;
case '>':
if(doc[sos -2] == '\\'){
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
name = nameStack.pop();
if (name.equals("para")) {
// end of para
int tempEos = eos;
eos = sos;
sos = parasos;
// System.out.println(new String(doc,sos,eos -sos));
readPara();
eos = tempEos;
}
break;
default:
break;
}
if (sos == eos) {
return;
}
ch = r.getChar();
}
}
private void outputSegmenet(String segVal, int segsos, int segeos, int strNum) throws IOException {
if (segVal.trim().length() == 0) {
return;
}
Object[] ar = new Object[4];
ar[0] = xliffIdex;
ar[1] = segsos;
ar[2] = segeos;
int segCounter = 0;
if (strNum > 1) {
String[] segVals = strSger.segment(segVal.toString());
// int temp = xliffIdex - 1;
for (String seg : segVals) {
if (seg.trim().length() == 0) {
continue;
}
segCounter++;
// System.out.println("seg(" + ar[0] + "):" + seg);
writeXliffFile(xliffIdex++, seg);
}
} else {
// System.out.println("sge:" + extraValBf);
segCounter = 1;
// System.out.println("seg(" + ar[0] + "):" + segVal);
writeXliffFile(xliffIdex++, segVal);
}
if (segCounter != 0) {
ar[3] = segCounter;
mrbf.addBuffer(ar);
}
}
private void writeXliffFile(int tuId, String sourceSeg) throws IOException {
xlfOs.write(" <trans-unit id=\"" + tuId++ + "\" xml:space=\"preserve\">\n" + " <source xml:lang=\""
+ srcLang + "\">" + sourceSeg + "</source>\n" + " </trans-unit>\n");
}
/**
* Get the text end by space
* @return
* @throws EOFException
* @throws MifParseException
*/
private String getContentEndBy(char n) throws EOFException, MifParseException {
StringBuffer bf = new StringBuffer();
if(n == '>'){
//need process escape character '>' represent as '\>'
char a = r.getCharAfterIgnore();
char pre = a;
while (true) {
if(a == '>' && pre !='\\' ){
break;
}
bf.append(a);
pre = a;
a = r.getChar();
}
}else {
char a = r.getCharAfterIgnore();
while (a != n) {
bf.append(a);
a = r.getChar();
}
}
sos--;
return bf.toString();
}
/**
* Get current statement name
* @return
* @throws EOFException
* @throws MifParseException ;
*/
private String getStatmentName() throws EOFException, MifParseException{
StringBuffer bf = new StringBuffer();
char a = r.getCharAfterIgnore();
while (true) {
if(a == ' ' || a == '\n' || a == '<' || a == '\r' || a == '\t' ){
break;
}
bf.append(a);
a = r.getChar();
}
sos--;
if(bf.length() == 0){
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
return bf.toString().toLowerCase();
}
/**
* Get the statement value,the text in `'
* @return
* @throws MifParseException
* @throws EOFException
*/
private String getValue() throws MifParseException, EOFException {
// char n = r.getCharAfterIgnore();
if (ch != '`') {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.statementError") + formatLineNumber());
}
StringBuffer bf = new StringBuffer();
char a = r.getChar();
while (a != '\'') {
bf.append(a);
a = r.getChar();
}
sos--;
return bf.toString();
}
private String formatLineNumber() {
return formatLineNumber(sos);
}
private String formatLineNumber(int sos) {
int os = 0;
int lineNumber = 0;
int lineos = 0;
while (os <= sos) {
if (doc[os] == '\n') {
lineNumber++;
lineos = os;
}
os++;
}
lineos = os - lineos;
return "\nLine Number: " + (lineNumber + 1) + " Offset: " + (lineos - 1);
}
class MifReader {
public MifReader() {
}
/**
* Get next character
* @return Return the next character
* @throws MifParseException
* @throws EOFException
*/
final public char getChar() throws MifParseException, EOFException {
if (sos >= eos) {
throw eofExp;
}
char n = doc[sos++];
if (n < 0)
throw new MifParseException(Messages.getString("mif.Mif2Xliff.characterError") + formatLineNumber());
return n;
}
/**
* Get the next char with ignore all \n,\t,\t and space
* @return the next none \n,\t,\t and space character
* @throws EOFException
* @throws MifParseException
*/
final public char getCharAfterIgnore() throws EOFException, MifParseException {
char n;
do {
n = getChar();
if ((n == ' ' || n == '\n' || n == '\t' || n == '\r')) {
} else {
return n;
}
n = getChar();
if ((n == ' ' || n == '\n' || n == '\t' || n == '\r')) {
} else {
return n;
}
} while (true);
}
/**
* Skip the specification character
* @param ch
* character
* @return if the next character is the specification character ,then skip it and return true; if return false
* ,will do nothing
*/
final public boolean skipChar(char ch) {
if (ch == doc[sos]) {
sos++;
return true;
} else {
return false;
}
}
}
}
| 21,314 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
MifParser.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/parser/MifParser.java | package net.heartsome.cat.converter.mif.parser;
import java.io.BufferedReader;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.MessageFormat;
import java.util.Stack;
import net.heartsome.cat.converter.mif.bean.Frame;
import net.heartsome.cat.converter.mif.bean.Marker;
import net.heartsome.cat.converter.mif.bean.MifParseBuffer;
import net.heartsome.cat.converter.mif.bean.Page;
import net.heartsome.cat.converter.mif.bean.Table;
import net.heartsome.cat.converter.mif.bean.TextFlow;
import net.heartsome.cat.converter.mif.bean.TextRect;
import net.heartsome.cat.converter.mif.common.MifParseException;
import net.heartsome.cat.converter.mif.common.UnSuportedFileExcetption;
import net.heartsome.cat.converter.mif.resource.Messages;
public class MifParser {
/** File start offset */
private int sos;
/** File end offset */
private int eos;
/** The temporary offset */
private int tos;
/** File content in char array */
char[] doc;
/** The MIF parse buffer */
MifParseBuffer mpbf;
/** Current character */
private char ch;
/** MIF reader */
private MifReader r;
private Stack<String> nameStack;
public MifParser() {
r = new MifReader();
mpbf = new MifParseBuffer();
nameStack = new Stack<String>();
}
public void parseFile(String file, String encoding) throws IOException, MifParseException, UnSuportedFileExcetption {
File path = new File(file);
FileInputStream in = new FileInputStream(path);
InputStreamReader inr = new InputStreamReader(in, encoding);
BufferedReader bfr = new BufferedReader(inr);
char[] doc = new char[(int) path.length()];
bfr.read(doc);
in.close();
bfr.close();
inr.close();
setDoc(doc);
parse();
}
public void setDoc(char[] doc) throws MifParseException {
if (doc.length == 0) {
throw new MifParseException("Invalidate file");
}
this.doc = doc;
sos = 0;
eos = doc.length;
decideEncoding();
validateFile();
}
public void parse() throws EOFException, MifParseException {
ch = r.getCharAfterIgnore();
int start = 0; // the top level element start offset
int markerFlg = 0; // the embed element start offset
while (true) {
switch (ch) {
case '<':
tos = sos - 1; // the statement start offset
String name = getStatmentName();
nameStack.push(name);
// System.out.println(name);
if (name.equals("aframes")) {
start = tos;
} else if (name.equals("tbl")) {
start = tos;
} else if (name.equals("page")) {
start = tos;
} else if (name.equals("textflow")) {
start = tos;
} else if (name.equals("importobject")) {
// the ImportObject statement individual parse
// the ImportObject statement contained specification of object data
parseImportObejct();
} else if (name.equals("marker")) {
// parse the marker element and get the index and cross-ref info
// This implement at 2012-08-15 for new requirement of extract the index text
markerFlg = tos;
} else if (name.equals("mtype") && markerFlg != 0) {
// check marker type
String v = getContentEndBy('>').trim();
if (!v.equals("2")) {
// 9: cross-ref , 2 : index
markerFlg = 0;
}
} else if (name.equals("mtext") && markerFlg != 0) {
// extract marker text
ch = r.getCharAfterIgnore();
if (ch == '`') {
int strsos = sos;
String text = getValue();
int streos = sos;
if (text.length() != 0) {
Marker m = new Marker(strsos, streos, text);
mpbf.appendMarker(m);
markerFlg = 0;
}
}
}
break;
case '`':
getValue(); // skip the value
break;
case '>':
if (doc[sos - 2] == '\\') {
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
name = nameStack.pop();
if (name.equals("aframes")) {
// System.out.println(new String(doc,start,sos - start));
int tempEos = eos;
eos = sos;
sos = start;
parseAframes();
eos = tempEos;
start = 0; // rest the record
} else if (name.equals("tbl")) {
int tempEos = eos;
eos = sos;
sos = start;
Table tbl = parseTables();
if (tbl.validate()) {
mpbf.appendTbale(tbl);
}
eos = tempEos;
start = 0; // rest the record
} else if (name.equals("page")) {
int tempEos = eos;
eos = sos;
sos = start;
Page page = parsePage();
if (page.validate()) {
mpbf.appendPage(page);
}
eos = tempEos;
start = 0; // rest the record
} else if (name.equals("textflow")) {
int tempEos = eos;
eos = sos;
sos = start;
TextFlow tf = parseTextFlow();
if (tf.validate()) {
mpbf.appendTextFlow(tf);
}
eos = tempEos;
start = 0; // rest the record
}
break;
default:
break;
}
if (sos == eos) {
return;
}
ch = r.getChar();
}
}
/**
* 目前只处理了UTF-8编码的BOM信息
* @throws MifParseException ;
*/
private void decideEncoding() throws MifParseException {
if (doc.length == 0) {
throw new MifParseException("当前文件是一个空文件");
}
StringBuffer bf = new StringBuffer();
for (int i = 0; i < doc.length; i++) {
char ch = doc[i];
if (ch == '\n' && bf.length() != 0) {
break;
}
bf.append(ch);
}
byte[] bys = bf.toString().getBytes();
if (bys[0] == -17) {
if (bys[1] == -69 && bys[2] == -65) {
sos += 1;
}
}
}
private void validateFile() throws MifParseException {
try {
ch = r.getCharAfterIgnore();
if (ch != '<') {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.fileNotStartProperly")
+ formatLineNumber());
}
tos = sos;
String name = getContentEndBy(' ').toLowerCase();
if (!name.equals("miffile")) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.fileNotStartProperly")
+ formatLineNumber(tos));
}
tos = sos;
String version = getContentEndBy('>');
try {
float f = Float.parseFloat(version);
if (f == 7.00 || f == 8.00 || f == 9.00 || f == 10.0) {
} else {
throw new MifParseException(MessageFormat.format(Messages.getString("mif.Mif2Xliff.unsuportVersion") + formatLineNumber(tos), f));
}
} catch (NumberFormatException e) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.invalidateVersionInfo")
+ formatLineNumber());
}
if (r.getChar() != '>') {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
} catch (EOFException e) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.fileEndError"));
}
}
private void parseImportObejct() throws EOFException, MifParseException {
ch = r.getCharAfterIgnore();
if (ch != '<') {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag") + formatLineNumber());
}
while (true) {
switch (ch) {
case '<':
String name = getStatmentName();
nameStack.push(name);
break;
case '`':
getValue(); // skip the content
break;
case '=':
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
if (nameStack.get(nameStack.size() - 1).equals("importobject")) {
// check the parent statement, ensure the line is the object data describing line
String endflag = ""; // end of the data describing the imported object
do {
getContentEndBy('\n'); // read to end of line
ch = r.getCharAfterIgnore();
if (ch != '&') {
throw new MifParseException(
Messages.getString("mif.Mif2Xliff.invalidateDataDescribingOfObject")
+ formatLineNumber());
}
while (ch == '&') { // Data describing line
getContentEndBy('\n'); // skip it
ch = r.getCharAfterIgnore();
}
if (ch != '=') {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.statementError")
+ formatLineNumber());
}
endflag = getContentEndBy('\n').trim();
if (endflag == null) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.statementError")
+ formatLineNumber());
}
} while (!endflag.equalsIgnoreCase("EndInset"));
}
break;
case '>':
if (doc[sos - 2] == '\\') {
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
name = nameStack.pop();
if (name.equals("importobject")) {
// End of ImportObject statement
ch = r.getChar(); // read the next character and return, ensure continue to parse the file
return;
}
break;
default:
break;
}
ch = r.getChar();
}
}
private void parseAframes() throws EOFException, MifParseException {
ch = r.getCharAfterIgnore();
int start = 0;
while (true) {
switch (ch) {
case '<':
tos = sos - 1;
String name = getStatmentName();
nameStack.push(name);
if (name.equals("frame") && !nameStack.get(nameStack.size() - 2).equals("frame")) {
start = tos;
} else if (name.equals("importobject")) {
// the ImportObject statement individual parse
// the ImportObject statement contained specification of object data
parseImportObejct();
}
break;
case '`':
getValue();
break;
case '>':
if (doc[sos - 2] == '\\') {
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
name = nameStack.pop();
if (name.equals("frame")) {
// System.out.println(new String(doc,start,sos - start));
int temp = nameStack.size() - 1;
if (temp < 0 || !nameStack.get(temp).equals("frame")) {
int tempEos = eos;
eos = sos;
sos = start;
Frame fm = parseFrame();
mpbf.appendFrame(fm);
eos = tempEos;
}
}
break;
default:
break;
}
if (sos == eos) {
return;
}
ch = r.getChar();
}
}
private Frame parseFrame() throws EOFException, MifParseException {
Frame fm = new Frame();
int tempsos = sos; // the top level frame start sos
fm.setOffset(sos);
fm.setEndOffset(eos);
int start = 0;
int framestart = 0;
ch = r.getCharAfterIgnore();
while (true) {
switch (ch) {
case '<':
tos = sos - 1;
String name = getStatmentName();
nameStack.push(name);
if (name.equals("textrect")) {
start = tos;
}
if (name.equals("frame") && tos != tempsos) {
framestart = tos;
}
if (name.equals("id") && nameStack.get(nameStack.size() - 2).equals("frame")) {
String content = getContentEndBy('>');
content = content.trim(); // clear space
fm.setId(content);
}
if (name.equals("importobject")) {
// the ImportObject statement individual parse
// the ImportObject statement contained specification of object data
parseImportObejct();
}
break;
case '`':
getValue();
break;
case '>':
if (doc[sos - 2] == '\\') {
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
name = nameStack.pop();
if (name.equals("textrect")) {
// System.out.println(new String(doc, start, sos - start));
int tempEos = eos;
eos = sos;
sos = start;
TextRect tr = parseTextRect();
if (tr.validate()) {
fm.appendTextRect(tr);
}
eos = tempEos;
} else if (name.equals("frame") && framestart != 0) {
System.out.println(new String(doc, framestart, sos - framestart));
int tempEos = eos;
eos = sos;
sos = framestart;
Frame fm1 = parseFrame();
mpbf.appendFrame(fm1);
eos = tempEos;
framestart = 0; // reset for next time use
}
break;
default:
break;
}
if (sos == eos) {
return fm;
}
ch = r.getChar();
}
}
private TextRect parseTextRect() throws EOFException, MifParseException {
TextRect tr = new TextRect();
ch = r.getCharAfterIgnore();
while (true) {
switch (ch) {
case '<':
String name = getStatmentName();
nameStack.push(name);
if (name.equals("id")) {
String content = getContentEndBy('>');
content = content.trim(); // clear the space
tr.setId(content);
}
if (name.equals("shaperect")) {
tos = sos;
String content = getContentEndBy('>');
char[] c = content.toCharArray();
String[] r = new String[4];
StringBuffer bf = new StringBuffer();
int j = 0;
for (int i = 0; i < c.length; i++) {
char m = c[i];
if ((m >= '0' && m <= '9') || m == '.') {
bf.append(m);
}
if (m == ' ' && bf.length() != 0) {
r[j++] = bf.toString();
bf.delete(0, bf.length());
}
}
if (r.length != 4) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.statementError")
+ formatLineNumber(tos));
}
String vp = r[1];
char e = vp.charAt(vp.length() - 1);
if (e < '0' && e > '9') {
vp = vp.substring(0, vp.length() - 1);
}
tr.setvPosition(vp);
}
break;
case '`':
getValue();
break;
case '>':
if (doc[sos - 2] == '\\') {
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
nameStack.pop();
break;
default:
break;
}
if (sos == eos) {
return tr;
}
ch = r.getChar();
}
}
private Table parseTables() throws EOFException, MifParseException {
Table tbl = new Table();
tbl.setOffset(sos);
tbl.setEndOffset(eos);
ch = r.getCharAfterIgnore();
while (true) {
switch (ch) {
case '<':
String name = getStatmentName();
nameStack.push(name);
if (name.equals("tblid")) {
String content = getContentEndBy('>');
content = content.trim(); // clear the space
tbl.setId(content);
}
break;
case '`':
getValue();
break;
case '>':
if (doc[sos - 2] == '\\') {
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
nameStack.pop();
break;
default:
break;
}
if (sos == eos) {
return tbl;
}
ch = r.getChar();
}
}
private Page parsePage() throws EOFException, MifParseException {
Page page = new Page();
page.setOffset(sos);
page.setEndOffset(eos);
int start = 0;
ch = r.getCharAfterIgnore();
while (true) {
switch (ch) {
case '<':
tos = sos - 1;
String name = getStatmentName();
nameStack.push(name);
if (name.equals("pagetype")) {
String content = getContentEndBy('>');
content = content.trim();
page.setPageType(content);
}
if (name.equals("pagetag")) {
ch = r.getCharAfterIgnore();
String pageTag = getValue();
pageTag = pageTag.trim();
page.setPageTag(pageTag);
}
if (name.equals("textrect")) {
start = tos;
}
if (name.equals("importobject")) {
// the ImportObject statement individual parse
// the ImportObject statement contained specification of object data
parseImportObejct();
}
break;
case '`':
getValue();
break;
case '>':
if (doc[sos - 2] == '\\') {
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
name = nameStack.pop();
if (name.equals("textrect")) {
// System.out.println(new String(doc,start,sos - start));
int tempEos = eos;
eos = sos;
sos = start;
TextRect tr = parseTextRect();
if (tr.validate()) {
page.appendTextRect(tr);
}
eos = tempEos;
start = 0;
}
break;
default:
break;
}
if (sos == eos) {
return page;
}
ch = r.getChar();
}
}
private TextFlow parseTextFlow() throws EOFException, MifParseException {
TextFlow tf = new TextFlow();
tf.setOffset(sos);
tf.setEndOffset(eos);
ch = r.getCharAfterIgnore();
while (true) {
switch (ch) {
case '<':
String name = getStatmentName();
nameStack.push(name);
if (name.equals("textrectid") && (tf.getTextRectId() == null || tf.getTextRectId().equals(""))) {
String content = getContentEndBy('>');
content = content.trim();
tf.setTextRectId(content);
}
break;
case '`':
getValue();
break;
case '>':
if (doc[sos - 2] == '\\') {
break;
}
if (nameStack.isEmpty()) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag")
+ formatLineNumber());
}
name = nameStack.pop();
break;
default:
break;
}
if (sos == eos) {
return tf;
}
ch = r.getChar();
}
}
/**
* Get the text before specify character
* @return
* @throws EOFException
* @throws MifParseException
*/
private String getContentEndBy(char n) throws EOFException, MifParseException {
StringBuffer bf = new StringBuffer();
if (n == '>') {
// need process escape character '>' represent as '\>'
char a = r.getCharAfterIgnore();
char pre = a;
while (true) {
if (a == '>' && pre != '\\') {
break;
}
bf.append(a);
pre = a;
a = r.getChar();
}
} else {
char a = r.getCharAfterIgnore();
while (a != n) {
bf.append(a);
a = r.getChar();
}
}
sos--;
return bf.toString();
}
/**
* Get current statement name
* @return
* @throws EOFException
* @throws MifParseException
* ;
*/
private String getStatmentName() throws EOFException, MifParseException {
StringBuffer bf = new StringBuffer();
char a = r.getCharAfterIgnore();
while (true) { // TODO validate '<' and '>'
if (a == ' ' || a == '\n' || a == '<' || a == '\r' || a == '\t') {
break;
}
bf.append(a);
a = r.getChar();
}
sos--;
if (bf.length() == 0) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.mismatchStartOrEndTag") + formatLineNumber());
}
return bf.toString().toLowerCase();
}
/**
* Get the statement value,the text in `'
* @return
* @throws MifParseException
* @throws EOFException
*/
private String getValue() throws MifParseException, EOFException {
// char n = r.getCharAfterIgnore();
if (ch != '`') {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.statementError") + formatLineNumber());
}
StringBuffer bf = new StringBuffer();
char a = r.getChar();
while (a != '\'') {
bf.append(a);
a = r.getChar();
}
sos--;
return bf.toString();
}
private String formatLineNumber() {
return formatLineNumber(sos);
}
private String formatLineNumber(int sos) {
int os = 0;
int lineNumber = 0;
int lineos = 0;
while (os <= sos) {
if (doc[os] == '\n') {
lineNumber++;
lineos = os;
}
os++;
}
lineos = os - lineos;
return "\n" + Messages.getString("mif.Mif2Xliff.linenumber") + (lineNumber + 1)
+ Messages.getString("mif.Mif2Xliff.column") + (lineos - 1);
}
class MifReader {
public MifReader() {
}
/**
* Get next character
* @return Return the next character
* @throws MifParseException
* @throws EOFException
*/
final public char getChar() throws MifParseException, EOFException {
if (sos >= eos) {
throw new EOFException(Messages.getString("mif.Mif2Xliff.fileEndError"));
}
char n = doc[sos++];
if (n < 0)
throw new MifParseException(Messages.getString("mif.Mif2Xliff.characterError") + formatLineNumber());
return n;
}
/**
* Get the next char with ignore all \n,\t,\t and space
* @return the next none \n,\t,\t and space character
* @throws EOFException
* @throws MifParseException
*/
final public char getCharAfterIgnore() throws EOFException, MifParseException {
char n;
do {
n = getChar();
if (n < 0) {
throw new MifParseException(Messages.getString("mif.Mif2Xliff.characterError") + formatLineNumber());
}
if ((n == ' ' || n == '\n' || n == '\t' || n == '\r')) {
} else {
return n;
}
n = getChar();
if ((n == ' ' || n == '\n' || n == '\t' || n == '\r')) {
} else {
return n;
}
} while (true);
}
/**
* Skip the specification character
* @param ch
* character
* @return if the next character is the specification character ,then skip it and return true; if return false
* ,will do nothing
*/
final public boolean skipChar(char ch) {
if (ch == doc[sos]) {
sos++;
return true;
} else {
return false;
}
}
}
}
| 21,078 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
ExtractParaline.java | /FileExtraction/Java_unseen/heartsome_translationstudio8/hsconverter/net.heartsome.cat.converter.MIF/src/net/heartsome/cat/converter/mif/parser/ExtractParaline.java | package net.heartsome.cat.converter.mif.parser;
import java.io.EOFException;
import java.util.Stack;
import net.heartsome.cat.converter.mif.common.MifParseException;
public class ExtractParaline {
char[] doc;
int sos;
int eos;
int tempos;
private EOFException eofExp;
Stack<String> nameStack = new Stack<String>();
char ch;
public ExtractParaline() {
doc = content.toCharArray();
sos = 0;
eos = doc.length;
eofExp = new EOFException("end of file");
}
public void readParaLine(){
}
public static void main(String[] args){
}
class MifReader {
public MifReader() {
}
/**
* Get next character
*
* @return Return the next character
* @throws MifParseException
* @throws EOFException
*/
final public char getChar() throws MifParseException, EOFException {
if (sos >= eos) {
throw eofExp;
}
char n = doc[sos++];
if (n < 0)
throw new MifParseException("read error: invalid Character");
return n;
}
/**
* Get the next char with ignore all \n,\t,\t and space
*
* @return the next none \n,\t,\t and space character
* @throws EOFException
* @throws MifParseException
*/
final public char getCharAfterIgnore() throws EOFException, MifParseException {
char n;
do {
n = getChar();
if ((n == ' ' || n == '\n' || n == '\t' || n == '\r')) {
} else {
return n;
}
n = getChar();
if ((n == ' ' || n == '\n' || n == '\t' || n == '\r')) {
} else {
return n;
}
} while (true);
}
/**
* Skip the specification character
*
* @param ch
* character
* @return if the next character is the specification character ,then
* skip it and return true; if return false ,will do nothing
*/
final public boolean skipChar(char ch) {
if (ch == doc[sos]) {
sos++;
return true;
} else {
return false;
}
}
}
private String content =
// "<Para \n" +
// " <Unique 1064386>\n" +
// " <PgfTag `SafetyText'>\n" +
" <ParaLine \n"+
" <String `This installation guide provides basic guidelines for the Rosemount 644. It does not '>\n" +
" > # end of ParaLine\n" +
" <ParaLine \n" +
" <String `provide instructions for detailed configuration, diagnostics, maintenance, service, '>\n" +
" <Char HardReturn>\n" +
" > # end of ParaLine\n" +
" <ParaLine \n" +
" <String `troubleshooting, or installation. Refer to the 644 Reference Manual (document number '>\n" +
" > # end of ParaLine\n" +
" <ParaLine \n" +
" <String `00809-0100-4728) for more instruction. The manual and this QIG are also available '>\n" +
" > # end of ParaLine\n" +
" <ParaLine \n" +
" <String `electronically on www.rosemount.com.'>\n" +
" > # end of ParaLine\n" //+
// "> # end of Para\n"// +
//"<para \n" +
//" <ParaLine \n" +
//" <String `T (US) '>\n" +
//" <Char Tab>\n" +
//" <String `(800) 999-9307'>\n" +
//" <Char HardReturn>\n" +
//" > # end of ParaLine\n" +
//"> # end of Para"
;
}
| 3,205 | Java | .java | heartsome/translationstudio8 | 83 | 45 | 18 | 2014-06-03T17:56:15Z | 2020-10-13T06:46:15Z |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.