protected async void SaveAsButton_Click(object sender, RoutedEventArgs e)
{
FileSavePicker savePicker = new FileSavePicker();
savePicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
// Dropdown of file types the user can save the file as
if (CurrentFile.Language != null)
{
CurrentFile.Language.AddLanguageSupport(savePicker);
}
else
{
LanguageSupport.AddLanguageSupport(savePicker);
}
// Default file name if the user does not type one in or select a file to replace
savePicker.SuggestedFileName = "New Document";
StorageFile file = await savePicker.PickSaveFileAsync();
if (file != null)
{
CurrentFile = await FileStorage.RegisterFile(storageFile : file);
await SaveFile();
}
}
private void StartVericut()
{
try
{
if (!File.Exists(Variables.vericut_fpath))
{
MessageDisplay.ShowError(
LanguageSupport.Translate("Vericut path {0} is invalid. The file doesn't exist."), Variables.vericut_fpath);
return;
}
if (!File.Exists(Variables.vcproj_fpath))
{
MessageDisplay.ShowError(
LanguageSupport.Translate("Vericut project {0} doesn't exist. Can't open it in VERICUT."), Variables.vcproj_fpath);
return;
}
using (Process proc = new Process())
{
proc.StartInfo.FileName = Variables.vericut_fpath;
proc.StartInfo.Arguments = String.Format("\"{0}\"", Variables.vcproj_fpath);
proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
proc.Start();
proc.WaitForExit(0);
if (proc != null)
{
proc.Dispose();
}
}
}
catch (Exception Ex)
{
LogFile.WriteException(Ex, "StartVericut");
}
}
// Use this for initialization
void Start()
{
LanguageSupport ls = new LanguageSupport();
ls.LoadLanguage(LanguageSupport.Language.RU);
Debug.logger.Log(ls.GetString("d_exit"));
}
//private GameOverCanvas gameOverCanvas;
void Start()
{
optionsMainCanvas.gameObject.SetActive(false);
helpCanvas.gameObject.SetActive(false);
helpVideo.gameObject.SetActive(false);
bgObject.gameObject.SetActive(false);
langSupport = FindObjectOfType <LanguageSupport>();
helpCanvas.gameObject.SetActive(false);
gameCanvas = FindObjectOfType <UIHandler>();
startGameCanvas = FindObjectOfType <StartGameCanvas>();
//gameOverCanvas = FindObjectOfType<GameOverCanvas>();
gameEngine = FindObjectOfType <GameEngine>();
audioSource = Camera.main.GetComponent <AudioSource>();
storageEngine = FindObjectOfType <StorageEngine>();
}
static void Main(string[] args)
{
var optionsBuilder = new DbContextOptionsBuilder <AdventureWorksContext>();
optionsBuilder.UseSqlServer(Settings.Adventure);
AdventureWorksContext context = new AdventureWorksContext(optionsBuilder.Options);
new IntroAnimation().Play();
History history = new History(context);
history.Presenter();
LanguageSupport language = new LanguageSupport(context);
language.Presenter();
QueryOperators queryOperators = new QueryOperators();
queryOperators.Presenter();
DeferredExecution deferred = new DeferredExecution(context);
deferred.Presenter();
Performance perf = new Performance(context);
perf.PerformancePresenter();
Console.ReadLine();
}
public void ConfirmCatPurchase(Cat cat)
{
/*
* Buy <catType> for <X> gold?
* Yes No
*/
if (cat.getCatAsset().price > GameControl.control.playerData.gold)
{
GameControl.control.NotEnoughGoldPrompt(GameControl.control.transform);
return;
}
GameControl.control.YesNoPrompt(LanguageSupport.BuyPrompt(cat.Name,
CatIAP.goldStr + cat.getCatAsset().price.ToString()), GameControl.control.transform,
() =>
{
GameControl.control.checkDeckAvailability(GameControl.control.transform,
(bool deckAvailable) =>
{
if (deckAvailable)
{
buyCat(cat);
}
});
}).RewardBackground();
}
public void NotEnoughGoldPrompt(Transform t, UnityAction onComplete = null)
{
getSoundManager().playError();
Notification n = GameObject.Instantiate(notificationPrefab, t, false).GetComponent <Notification>();
if (n == null)
{
return;
}
n.YesNoPrompt(LanguageSupport.NotEnoughGold(), () =>
{
Transform shop = Instantiate(Resources.Load <GameObject>("miscPrefabs/CoinShop"), t, false).transform;
Button exit = null;
if (onComplete != null)
{
exit = shop.GetChild(0).Find("exit").GetComponent <Button>();
exit.onClick.AddListener(onComplete);
}
if (exit != null && t != transform)
{
GetComponent <Canvas>().enabled = true;
transform.GetChild(0).gameObject.SetActive(false);
exit.onClick.AddListener(() => transform.GetChild(0).gameObject.SetActive(true));
}
}, onComplete, "Buy Gold");
n.RewardBackground();
}
private static void CheckTLBCompatibility()
{
Version vnum = new Version(1, 0, 0, 0);
try
{
try
{
vnum = new Version(FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion);
}
catch { }
// the featurecam tlb version is a property on the app now adays...
// if the app doesn't have that propety, the next line will throw a com exception
if (fc.MajorTLBVersionNum != vnum.Build)
{
MessageDisplay.ShowWarning(
LanguageSupport.Translate("Warning: This dll add-in was compiled against v{0} of FeatureCAM tlb."), vnum.Build.ToString());
}
}
catch
{
// must be tlb version 1?
MessageDisplay.ShowWarning(
LanguageSupport.Translate("Warning: This dll add-in was compiled against v{0} of FeatureCAM tlb, and should not be run with older versions of FeatureCAM."), vnum.Build.ToString());
}
}
private async Task NewFile(NewFileItem item)
{
try
{
FileSavePicker savePicker = new FileSavePicker();
savePicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
// Dropdown of file types the user can save the file as
if (item != null)
{
item.Language.AddLanguageSupport(savePicker);
}
else
{
LanguageSupport.AddLanguageSupport(savePicker);
}
// Default file name if the user does not type one in or select a file to replace
savePicker.SuggestedFileName = "New Document";
StorageFile storageFile = await savePicker.PickSaveFileAsync();
if (storageFile != null)
{
await FileIO.WriteTextAsync(storageFile, string.Empty);
RecentFile file = await FileStorage.RegisterFile(storageFile : storageFile, overrideEntry : true);
await OpenFile(Frame, file);
}
}
catch (Exception ex)
{
Log.Error(ex);
}
}
private void btn_OK_Click(object sender, EventArgs e)
{
if (cb_solids.CheckedItems.Count == 0)
{
return;
}
if (cb_export_as.SelectedItem == null)
{
MessageDisplay.ShowError(
LanguageSupport.Translate("You have to select whether to export selected solids as clamps or design."));
return;
}
if (cb_attach_to.SelectedItem == null)
{
MessageDisplay.ShowError(
LanguageSupport.Translate("You have to select attach component."));
return;
}
selected_solids = new List <string>();
for (int i = 0; i < cb_solids.CheckedItems.Count; i++)
{
selected_solids.Add(cb_solids.CheckedItems[i].ToString());
}
attach_to = cb_attach_to.SelectedItem.ToString();
export_as_clamp = (cb_export_as.SelectedIndex == 0);
fm_doc = null;
this.Close();
}
private static void InsertIntoBnrachAndComparison(
CoverageInfo info, XElement root, LanguageSupport support, string relativePath)
{
var analyzer = support.AstAnalyzer;
var branchNodes = analyzer.FindBranches(root);
var startBranchIndex = info.Targets.Count;
var startBranchConditionIndex = info.TargetGroups.Count;
foreach (var branchNode in branchNodes.ToList())
{
// 全ての論理項を列挙
var condNodeList = analyzer.FindConditions(branchNode).ToList();
// 論理項に測定用コードを埋め込み，カバレッジ情報を生成
var condElements = InsertIntoConditionCoverage(info, condNodeList, support,
relativePath);
// 条件分岐のカバレッジ情報を生成
var element = new CoverageElement(relativePath, branchNode, support.Tagger);
// 条件分岐と論理項のカバレッジ情報をまとめる
var elementGroup = new CoverageElementGroup(element, condElements);
info.TargetGroups.Add(elementGroup);
// 論理項を含む条件式か否かを判断
support.AstTransformer.InsertPredicate(
branchNode, info.Targets.Count,
elementGroup.Targets.Count > 0
? ElementType.Decision
: ElementType.DecisionAndCondition);
info.Targets.Add(element);
}
info.BranchConditionRanges.Add(Tuple.Create(startBranchConditionIndex,
info.TargetGroups.Count));
info.BranchRanges.Add(Tuple.Create(startBranchIndex, info.Targets.Count));
}
private static void InsertIntoSwitchCase(
CoverageInfo info, XElement node, LanguageSupport support, string relativePath)
{
var analyzer = support.AstAnalyzer;
var startSwitchIndex = info.TargetGroups.Count;
var switchNodes = analyzer.FindSwitches(node);
foreach (var switchNode in switchNodes.ToList())
{
var caseElements = new List <CoverageElement>();
var caseNodes = analyzer.FindCaseLabelTails(switchNode);
foreach (var caseNode in caseNodes.ToList())
{
// ステートメントに測定用コードを埋め込む
support.AstTransformer.InsertStatementAfter(
caseNode, info.Targets.Count, Done, ElementType.SwitchCase);
// カバレッジ情報を生成
var covElem = new CoverageElement(relativePath, caseNode, support.Tagger);
info.Targets.Add(covElem);
caseElements.Add(covElem);
}
// switchのカバレッジ情報を生成
var element = new CoverageElement(relativePath, switchNode, support.Tagger);
// 条件分岐と論理項のカバレッジ情報をまとめる
var elementGroup = new CoverageElementGroup(element, caseElements);
info.TargetGroups.Add(elementGroup);
}
info.SwitchRanges.Add(Tuple.Create(startSwitchIndex, info.TargetGroups.Count));
}
protected async override Task LoadState(LoadStateEventArgs e)
{
// TODO: Assign a bindable collection of items to this.DefaultViewModel["Items"]
var newFiles = new ObservableCollection <IDataItem>();
newFiles.Add(new OpenFileItem());
foreach (var item in LanguageSupport.GetItemsNewFile())
{
newFiles.Add(item);
}
this.DefaultViewModel["NewFiles"] = newFiles;
var recentFiles = new ObservableCollection <IDataItem>();
// recentFiles.Add(new RecentFile(fullPath: "C:/test/abc.txt", printErrors: true));
foreach (RecentFile file in FileStorage.RecentFiles)
{
file.PrintErrors = true;
await file.Check();
recentFiles.Add(file);
}
this.DefaultViewModel["RecentFiles"] = recentFiles;
}
public static string GetCoveragedCode(
FileInfo codeFile, CoverageInfo info, LanguageSupport support)
{
string relativePath;
return(GetCoveragedCode(codeFile, info, support, out relativePath));
}
/// <summary>
/// Instruments production code for measuring code coverage and returns the modifieid code.
/// </summary>
/// <param name="support">A support to measure coverage.</param>
/// <param name="fileInfo">A <c>FileInfo</c> instance to be instrumented.</param>
/// <returns>The modified production code.</returns>
public string InstrumentStatementAndPredicate(
LanguageSupport support, FileInfo fileInfo)
{
var root = support.CodeToXml.GenerateFromFile(fileInfo.FullName);
var inserter = support.AstTransformer;
var fileId = RegisterFile(fileInfo);
// ステートメントを挿入できるようにブロックを補う
inserter.SupplementBlock(root);
// switch文を正しく測定できるようにdefault節を追加する
inserter.SupplementDefaultCase(root);
var analyzer = support.AstAnalyzer;
var funcs = analyzer.FindFunctions(root);
foreach (var func in funcs)
{
var funcName = analyzer.GetFunctionName(func);
var funcId = RegisterFunction(fileId, funcName, CodeRange.Locate(func));
InstrumentStatement(support, fileId, funcId, inserter, func);
InstrumentBranch(support, fileId, funcId, inserter, func);
}
// Add import for logging executed items
inserter.InsertImport(root);
return(support.XmlToCode.Generate(root));
}
public static string WriteCoveragedCode(
LanguageSupport support, CoverageInfo info, FileInfo codeFile, DirectoryInfo outDir)
{
string relativePath;
var code = GetCoveragedCode(codeFile, info, support, out relativePath);
return(WriteCode(relativePath, outDir, code));
}
public static string AnalyzeAndWriteIdentifiedTest(
LanguageSupport support, TestInfo info, FileInfo fullPath, DirectoryInfo outDirPath)
{
string relativePath;
var code = GetIdentifiedTest(fullPath, info, support, out relativePath);
return(WriteCode(relativePath, outDirPath, code));
}
public void WriteInstrumentedTestCode(LanguageSupport mode, FileInfo inFileInfo)
{
var relativePath = ParaibaPath.GetRelativePath(inFileInfo.FullName, BaseDirInfo.FullName);
var outFileInfo = OutDirInfo.GetFile(relativePath);
var code = InstrumentTestCase(mode, inFileInfo, BaseDirInfo);
outFileInfo.Directory.Create();
File.WriteAllText(outFileInfo.FullName, code);
}
public async Task Check()
{
if (StorageFile == null)
{
if (string.IsNullOrWhiteSpace(Token))
{
Log.Error("File has no token!");
}
else
{
try
{
StorageFile = await StorageApplicationPermissions.FutureAccessList.GetFileAsync(token : Token);
// StorageFile = await Windows.Storage.StorageFile.GetFileFromPathAsync(FullPath);
}
catch (Exception e)
{
if (PrintErrors)
{
Log.Error("Check:StorageFile: ", e);
}
else
{
Log.Debug("Check:StorageFile: ", e);
}
}
}
}
if (string.IsNullOrWhiteSpace(FullPath))
{
if (StorageFile != null)
{
FullPath = StorageFile.Path;
}
else
{
Log.Error("Bug! Both StorageFile and FullPath are null!");
}
}
IsFullPathSupported = FullPath != null;
IsValid = StorageFile != null && Token != null;
Language = LanguageSupport.FindByExtension(fullPath: FullPath);
if (Language != null)
{
BackgroundColor = Language.Color;
}
else
{
BackgroundColor = "#ffffffff";
}
//Log._Test(BackgroundColor);
}
public UCSsDlg_TurnMill(int selected_setup_index)
{
setup_index = selected_setup_index;
InitializeComponent();
this.Text = LanguageSupport.Translate(this.Text);
label2.Text = LanguageSupport.Translate(label2.Text);
label7.Text = LanguageSupport.Translate(label7.Text);
label4.Text = LanguageSupport.Translate(label4.Text);
label5.Text = LanguageSupport.Translate(label5.Text);
label1.Text = LanguageSupport.Translate(label1.Text);
label3.Text = LanguageSupport.Translate(label3.Text);
btn_OK.Text = LanguageSupport.Translate(btn_OK.Text);
btn_Cancel.Text = LanguageSupport.Translate(btn_Cancel.Text);
cb_attach_ucss_to_subspindle.Enabled = !Variables.are_all_setups_milling;
label3.Enabled = !Variables.are_all_setups_milling;
/* Attach axis */
cb_attach_ucss_to.Items.Clear();
cb_attach_ucss_to_subspindle.Items.Clear();
if (Variables.setups_info[setup_index].attach_components != null)
{
foreach (string attach_comp in Variables.setups_info[setup_index].attach_components)
{
cb_attach_ucss_to.Items.Add(attach_comp);
cb_attach_ucss_to_subspindle.Items.Add(attach_comp);
}
}
if (Variables.setups_info[setup_index].attach_ucss_to != "" && cb_attach_ucss_to.Items.Contains(Variables.setups_info[setup_index].attach_ucss_to))
{
cb_attach_ucss_to.SelectedItem = Variables.setups_info[setup_index].attach_ucss_to;
}
if (Variables.setups_info[setup_index].attach_ucss_to_subspindle != "" && cb_attach_ucss_to_subspindle.Items.Contains(Variables.setups_info[setup_index].attach_ucss_to_subspindle))
{
cb_attach_ucss_to_subspindle.SelectedItem = Variables.setups_info[setup_index].attach_ucss_to_subspindle;
}
cb_ucs_location.Items.Clear();
cb_ucs_location_subspindle.Items.Clear();
if (Variables.all_ucss != null)
{
foreach (UCS ucs in Variables.all_ucss)
{
cb_ucs_location.Items.Add(ucs.name);
cb_ucs_location_subspindle.Items.Add(ucs.name);
}
}
if (Variables.setups_info[setup_index].attach_ucs != "" && cb_ucs_location.Items.Contains(Variables.setups_info[setup_index].attach_ucs))
{
cb_ucs_location.SelectedItem = Variables.setups_info[setup_index].attach_ucs;
}
if (Variables.setups_info[setup_index].attach_ucs_subspindle != "" && cb_ucs_location.Items.Contains(Variables.setups_info[setup_index].attach_ucs_subspindle))
{
cb_ucs_location_subspindle.SelectedItem = Variables.setups_info[setup_index].attach_ucs_subspindle;
}
}
public static void VerifyCodeInsertion(LanguageSupport mode, string fileName)
{
var code = InsertInstrumentationCode(mode, fileName);
var expPath = Path.Combine(Fixture.GetCoverageExpectationPath(), fileName);
using (var reader = new StreamReader(expPath)) {
var expected = reader.ReadToEnd();
Assert.That(code, Is.EqualTo(expected));
}
}
public static string InsertInstrumentationCode(LanguageSupport mode, string fileName)
{
var info = new CoverageInfo(
Fixture.GetCoverageInputPath(), mode.Name, SharingMethod.SharedMemory);
var inPath = Path.Combine(Fixture.GetCoverageInputPath(), fileName);
var code = OccfCodeGenerator.GetCoveragedCode(new FileInfo(inPath), info, mode);
File.WriteAllText(Fixture.GetOutputPath(fileName), code);
return(code);
}
private void b_select_output_dir_Click(object sender, EventArgs e)
{
outputDirBrowserDialog1.Description = LanguageSupport.Translate("Select output directory");
outputDirBrowserDialog1.SelectedPath = Variables.doc_options.output_dirpath;
if (outputDirBrowserDialog1.ShowDialog() == DialogResult.OK)
{
tb_output_dir.Text = outputDirBrowserDialog1.SelectedPath;
Variables.doc_options.output_dirpath = tb_output_dir.Text;
}
}
void Start()
{
langSupport = FindObjectOfType <LanguageSupport>();
textSpawner = FindObjectOfType <TextSpawner>();
DontDestroyOnLoad(textSpawner);
continueText.text = langSupport.GetText("continue");
continueCanvas.gameObject.SetActive(false);
}
public static void TransofrmStatement(
CoverageInfo info, XElement root, LanguageSupport support, string relativePath) {
// ステートメントを挿入できるようにブロックを補う
support.AstTransformer.SupplementBlock(root);
InsertIntoStatement(info, root, support, relativePath);
InsertIntoVariableInitializer(info, root, support, relativePath);
// Add import for loggin executed items
support.AstTransformer.InsertImport(root);
}
public static void TransofrmStatement(
CoverageInfo info, XElement root, LanguageSupport support, string relativePath)
{
// ステートメントを挿入できるようにブロックを補う
support.AstTransformer.SupplementBlock(root);
InsertIntoStatement(info, root, support, relativePath);
InsertIntoVariableInitializer(info, root, support, relativePath);
// Add import for loggin executed items
support.AstTransformer.InsertImport(root);
}
private void InstrumentStatement(
LanguageSupport support, long fileId, long funcId, AstTransformer inserter, XElement func)
{
var stmts = support.AstAnalyzer.FindStatements(func);
foreach (var stmt in stmts)
{
var position = CodeRange.Locate(stmt);
var stmtId = RegisterStatement(fileId, funcId, position);
inserter.InsertStatementBefore(stmt, stmtId, CodeTransformer.Done, ElementType.Statement);
}
}
private void InstrumentBranch(
LanguageSupport support, long fileId, long funcId, AstTransformer inserter, XElement func)
{
var branches = support.AstAnalyzer.FindBranches(func);
foreach (var branch in branches)
{
var position = CodeRange.Locate(branch);
var branchId = RegisterBranch(fileId, funcId, position);
inserter.InsertPredicate(branch, branchId, ElementType.Decision);
}
}
public static string GetIdentifiedTest(
FileInfo testFile, TestInfo info, LanguageSupport support, out string relativePath)
{
relativePath = ParaibaPath.GetRelativePath(testFile.FullName, info.BasePath);
var ast = support.CodeToXml.GenerateFromFile(testFile.FullName);
// テストケース識別用コードの埋め込み
CodeTransformer.InsertIntoTestCase(info, ast, support, relativePath);
// コード生成
return(support.XmlToCode.Generate(ast));
}
public static void TransformPredicate(
CoverageInfo info, XElement root, LanguageSupport support, string relativePath) {
// switch文を正しく測定できるようにdefault節を追加する
support.AstTransformer.SupplementDefaultCase(root);
InsertIntoBranchAndCondition(info, root, support, relativePath);
InsertIntoSwitchCase(info, root, support, relativePath);
InsertIntoForeach(info, root, support, relativePath);
// Add import for loggin executed items
support.AstTransformer.InsertImport(root);
}
private void b_select_setup_template_Click(object sender, EventArgs e)
{
openSetupTemplateFileDialog1.Filter = LanguageSupport.Translate("VCPROJECT file (*.vcproject)|*.vcproject");
openSetupTemplateFileDialog1.FileName = "";
openSetupTemplateFileDialog1.CheckFileExists = true;
openSetupTemplateFileDialog1.Title = LanguageSupport.Translate("Select template VERICUT project for the setup");
if (openSetupTemplateFileDialog1.ShowDialog() == DialogResult.OK)
{
tb_setup_template_fpath.Text = openSetupTemplateFileDialog1.FileName;
Variables.setups_info[cb_setups.SelectedIndex].options.template_fpath = tb_setup_template_fpath.Text;
}
}
public static void TransformPredicate(
CoverageInfo info, XElement root, LanguageSupport support, string relativePath)
{
// switch文を正しく測定できるようにdefault節を追加する
support.AstTransformer.SupplementDefaultCase(root);
InsertIntoBranchAndCondition(info, root, support, relativePath);
InsertIntoSwitchCase(info, root, support, relativePath);
InsertIntoForeach(info, root, support, relativePath);
// Add import for loggin executed items
support.AstTransformer.InsertImport(root);
}
/// <summary>
/// Instruments test code for measuring code coverage and returns the modifieid code.
/// </summary>
/// <param name="support">A support to measure coverage.</param>
/// <param name="fileInfo">A <c>FileInfo</c> instance to be instrumented.</param>
/// <param name="baseDirInfo">A <c>DirectoryInfo</c> instance of base directory.</param>
/// <returns>The modified test code.</returns>
public string InstrumentTestCase(
LanguageSupport support, FileInfo fileInfo, DirectoryInfo baseDirInfo) {
var relativePath = ParaibaPath.GetRelativePath(fileInfo.FullName, baseDirInfo.FullName);
var root = support.CodeToXml.GenerateFromFile(fileInfo.FullName);
var inserter = support.AstTransformer;
var fileId = RegisterFile(fileInfo);
var targets = support.AstAnalyzer.FindTestCases(root);
foreach (var target in targets) {
var testCaseId = RegisterTestCase(fileId);
inserter.InsertTestCaseId(target, testCaseId, relativePath);
}
// Add import for logging executed items
inserter.InsertImport(root);
return support.XmlToCode.Generate(root);
}
public static void InstrumentStatementAndPredicate(
CoverageInfo info, XElement root, LanguageSupport support, string relativePath) {
// ステートメントを挿入できるようにブロックを補う
support.AstTransformer.SupplementBlock(root);
// switch文を正しく測定できるようにdefault節を追加する
support.AstTransformer.SupplementDefaultCase(root);
InsertIntoStatement(info, root, support, relativePath);
//InsertIntoBranchAndCondition(info, root, support, relativePath);
// Add the measurement code as a statement into switch and foreach
// after inserting the measurement code into statements
//InsertIntoSwitchCase(info, root, support, relativePath);
//InsertIntoForeach(info, root, support, relativePath);
// Add the measurement code as a prediction into variable initializers
// after inserting the measurement code into predictions
//InsertIntoVariableInitializer(info, root, support, relativePath);
// Add import for logging executed items
support.AstTransformer.InsertImport(root);
}
/// <summary>
/// Instruments production code for measuring code coverage and returns the modifieid code.
/// </summary>
/// <param name="support">A support to measure coverage.</param>
/// <param name="fileInfo">A <c>FileInfo</c> instance to be instrumented.</param>
/// <returns>The modified production code.</returns>
public string InstrumentStatementAndPredicate(
LanguageSupport support, FileInfo fileInfo) {
var root = support.CodeToXml.GenerateFromFile(fileInfo.FullName);
var inserter = support.AstTransformer;
var fileId = RegisterFile(fileInfo);
// ステートメントを挿入できるようにブロックを補う
inserter.SupplementBlock(root);
// switch文を正しく測定できるようにdefault節を追加する
inserter.SupplementDefaultCase(root);
var analyzer = support.AstAnalyzer;
var funcs = analyzer.FindFunctions(root);
foreach (var func in funcs) {
var funcName = analyzer.GetFunctionName(func);
var funcId = RegisterFunction(fileId, funcName, CodeRange.Locate(func));
InstrumentStatement(support, fileId, funcId, inserter, func);
InstrumentBranch(support, fileId, funcId, inserter, func);
}
// Add import for logging executed items
inserter.InsertImport(root);
return support.XmlToCode.Generate(root);
}
private void InstrumentStatement(
LanguageSupport support, long fileId, long funcId, AstTransformer inserter, XElement func) {
var stmts = support.AstAnalyzer.FindStatements(func);
foreach (var stmt in stmts) {
var position = CodeRange.Locate(stmt);
var stmtId = RegisterStatement(fileId, funcId, position);
inserter.InsertStatementBefore(stmt, stmtId, CodeTransformer.Done, ElementType.Statement);
}
}
private void InstrumentBranch(
LanguageSupport support, long fileId, long funcId, AstTransformer inserter, XElement func) {
var branches = support.AstAnalyzer.FindBranches(func);
foreach (var branch in branches) {
var position = CodeRange.Locate(branch);
var branchId = RegisterBranch(fileId, funcId, position);
inserter.InsertPredicate(branch, branchId, ElementType.Decision);
}
}
private static List<CoverageElement> InsertIntoConditionCoverage(
CoverageInfo info, ICollection<XElement> condNodeList, LanguageSupport support,
string relativePath) {
return condNodeList.SelectToList(
node => {
support.AstTransformer.InsertPredicate(node, info.Targets.Count,
ElementType.Condition);
var covElem = new CoverageElement(relativePath, node, support.Tagger);
info.Targets.Add(covElem);
return covElem;
});
}
private static void InsertIntoVariableInitializer(
CoverageInfo info, XElement root, LanguageSupport support, string relativePath) {
var statemetIndex = info.Targets.Count;
var nodes = support.AstAnalyzer.FindVariableInitializers(root);
foreach (var node in nodes.ToList()) {
// ステートメントに測定用コードを埋め込む
support.AstTransformer.InsertInitializer(node, info.Targets.Count,
ElementType.Statement);
// カバレッジ情報を生成
var covElem = new CoverageElement(relativePath, node, support.Tagger);
info.Targets.Add(covElem);
}
info.StatementRanges.Add(Tuple.Create(statemetIndex, info.Targets.Count));
}
private static void InsertIntoBnrachAndComparison(
CoverageInfo info, XElement root, LanguageSupport support, string relativePath) {
var analyzer = support.AstAnalyzer;
var branchNodes = analyzer.FindBranches(root);
var startBranchIndex = info.Targets.Count;
var startBranchConditionIndex = info.TargetGroups.Count;
foreach (var branchNode in branchNodes.ToList()) {
// 全ての論理項を列挙
var condNodeList = analyzer.FindConditions(branchNode).ToList();
// 論理項に測定用コードを埋め込み，カバレッジ情報を生成
var condElements = InsertIntoConditionCoverage(info, condNodeList, support,
relativePath);
// 条件分岐のカバレッジ情報を生成
var element = new CoverageElement(relativePath, branchNode, support.Tagger);
// 条件分岐と論理項のカバレッジ情報をまとめる
var elementGroup = new CoverageElementGroup(element, condElements);
info.TargetGroups.Add(elementGroup);
// 論理項を含む条件式か否かを判断
support.AstTransformer.InsertPredicate(
branchNode, info.Targets.Count,
elementGroup.Targets.Count > 0
? ElementType.Decision
: ElementType.DecisionAndCondition);
info.Targets.Add(element);
}
info.BranchConditionRanges.Add(Tuple.Create(startBranchConditionIndex,
info.TargetGroups.Count));
info.BranchRanges.Add(Tuple.Create(startBranchIndex, info.Targets.Count));
}
public static void InsertIntoTestCase(
TestInfo info, XElement root, LanguageSupport support, string relativePath) {
var nodes = support.AstAnalyzer.FindTestCases(root);
var trans = support.AstTransformer;
foreach (var node in nodes.ToList()) {
var id = info.TestCases.Count;
var testCase = trans.InsertTestCaseId(node, id, relativePath);
info.TestCases.Add(testCase);
}
// Add import for loggin executed items
support.AstTransformer.InsertImport(root);
}
private static List<CoverageElement> InsertIntoConditionAndComparison(
CoverageInfo info, ICollection<XElement> condNodeList, LanguageSupport support,
string relativePath) {
return condNodeList.SelectToList(
node => {
var elemsAndType = support.AstAnalyzer.GetComparedElements(node);
if (elemsAndType != null) {
var leftElement = elemsAndType.Item1;
var rightElement = elemsAndType.Item2;
var type = elemsAndType.Item3;
switch (type) {
case ComparatorType.Equal:
support.AstTransformer.InsertEqual(node, leftElement, rightElement,
info.Targets.Count, ElementType.Condition);
break;
case ComparatorType.NotEqual:
support.AstTransformer.InsertNotEqual(node, leftElement,
rightElement, info.Targets.Count, ElementType.Condition);
break;
case ComparatorType.LessThan:
support.AstTransformer.InsertLessThan(node, leftElement,
rightElement, info.Targets.Count, ElementType.Condition);
break;
case ComparatorType.GraterThan:
support.AstTransformer.InsertGraterThan(node, leftElement,
rightElement, info.Targets.Count, ElementType.Condition);
break;
default:
throw new ArgumentOutOfRangeException();
}
} else {
support.AstTransformer.InsertPredicate(node, info.Targets.Count,
ElementType.Condition);
}
var covElem = new CoverageElement(relativePath, node, support.Tagger);
info.Targets.Add(covElem);
return covElem;
});
}
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
LanguageSupport LanguageMgr = new LanguageSupport();
this.components = new System.ComponentModel.Container();
System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(frmMain));
this.lstAccounts = new System.Windows.Forms.ListView();
this.LiveId = new System.Windows.Forms.ColumnHeader();
this.Password = new System.Windows.Forms.ColumnHeader();
this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
this.kopyalasToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.tümünüKopyalaToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.btnClose = new System.Windows.Forms.Button();
this.label2 = new System.Windows.Forms.Label();
this.lnkGoTb = new System.Windows.Forms.LinkLabel();
this.contextMenuStrip1.SuspendLayout();
this.SuspendLayout();
//
// lstAccounts
//
this.lstAccounts.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
this.LiveId,
this.Password});
this.lstAccounts.ContextMenuStrip = this.contextMenuStrip1;
this.lstAccounts.FullRowSelect = true;
this.lstAccounts.Location = new System.Drawing.Point(12, 12);
this.lstAccounts.Name = "lstAccounts";
this.lstAccounts.Size = new System.Drawing.Size(398, 119);
this.lstAccounts.TabIndex = 0;
this.lstAccounts.UseCompatibleStateImageBehavior = false;
this.lstAccounts.View = System.Windows.Forms.View.Details;
//
// LiveId
//
this.LiveId.Text = LanguageMgr["LiveIdColumn"]; //"Live ID";
this.LiveId.Width = 222;
//
// Password
//
this.Password.Text = LanguageMgr["PasswordColumn"]; //"Password";
this.Password.Width = 169;
//
// contextMenuStrip1
//
this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.kopyalasToolStripMenuItem,
this.tümünüKopyalaToolStripMenuItem});
this.contextMenuStrip1.Name = "contextMenuStrip1";
this.contextMenuStrip1.Size = new System.Drawing.Size(165, 48);
//
// kopyalasToolStripMenuItem
//
this.kopyalasToolStripMenuItem.Name = "kopyalasToolStripMenuItem";
this.kopyalasToolStripMenuItem.Size = new System.Drawing.Size(164, 22);
this.kopyalasToolStripMenuItem.Text = LanguageMgr["Copy"]; //"Kopyala";
this.kopyalasToolStripMenuItem.Click += new System.EventHandler(this.kopyalasToolStripMenuItem_Click);
//
// tümünüKopyalaToolStripMenuItem
//
this.tümünüKopyalaToolStripMenuItem.Name = "tümünüKopyalaToolStripMenuItem";
this.tümünüKopyalaToolStripMenuItem.Size = new System.Drawing.Size(164, 22);
this.tümünüKopyalaToolStripMenuItem.Text = LanguageMgr["CopyAll"]; //"Tümünü kopyala";
this.tümünüKopyalaToolStripMenuItem.Click += new System.EventHandler(this.tümünüKopyalaToolStripMenuItem_Click);
//
// btnClose
//
this.btnClose.Location = new System.Drawing.Point(334, 137);
this.btnClose.Name = "btnClose";
this.btnClose.Size = new System.Drawing.Size(76, 23);
this.btnClose.TabIndex = 1;
this.btnClose.Text = LanguageMgr["Ok"]; //"Ok";
this.btnClose.UseVisualStyleBackColor = true;
this.btnClose.Click += new System.EventHandler(this.btnClose_Click);
//
// label2
//
this.label2.AutoSize = true;
this.label2.Location = new System.Drawing.Point(13, 142);
this.label2.Name = "label2";
this.label2.Size = new System.Drawing.Size(46, 13);
this.label2.TabIndex = 3;
this.label2.Text = "2009 © ";
//
// lnkGoTb
//
this.lnkGoTb.AutoSize = true;
this.lnkGoTb.Location = new System.Drawing.Point(55, 142);
this.lnkGoTb.Name = "lnkGoTb";
this.lnkGoTb.Size = new System.Drawing.Size(62, 13);
this.lnkGoTb.TabIndex = 4;
this.lnkGoTb.TabStop = true;
this.lnkGoTb.Text = "Oguz Kartal";
this.lnkGoTb.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.lnkGoTb_LinkClicked);
//
// frmMain
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(422, 168);
this.Controls.Add(this.btnClose);
this.Controls.Add(this.lnkGoTb);
this.Controls.Add(this.lstAccounts);
this.Controls.Add(this.label2);
this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
this.MaximizeBox = false;
this.Name = "frmMain";
this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
this.Text = LanguageMgr["Title"]; //"Windows Live Messenger Stored Password Recover";
this.Load += new System.EventHandler(this.frmMain_Load);
this.contextMenuStrip1.ResumeLayout(false);
this.ResumeLayout(false);
this.PerformLayout();
}
private static void InsertIntoSwitchCase(
CoverageInfo info, XElement node, LanguageSupport support, string relativePath) {
var analyzer = support.AstAnalyzer;
var startSwitchIndex = info.TargetGroups.Count;
var switchNodes = analyzer.FindSwitches(node);
foreach (var switchNode in switchNodes.ToList()) {
var caseElements = new List<CoverageElement>();
var caseNodes = analyzer.FindCaseLabelTails(switchNode);
foreach (var caseNode in caseNodes.ToList()) {
// ステートメントに測定用コードを埋め込む
support.AstTransformer.InsertStatementAfter(
caseNode, info.Targets.Count, Done, ElementType.SwitchCase);
// カバレッジ情報を生成
var covElem = new CoverageElement(relativePath, caseNode, support.Tagger);
info.Targets.Add(covElem);
caseElements.Add(covElem);
}
// switchのカバレッジ情報を生成
var element = new CoverageElement(relativePath, switchNode, support.Tagger);
// 条件分岐と論理項のカバレッジ情報をまとめる
var elementGroup = new CoverageElementGroup(element, caseElements);
info.TargetGroups.Add(elementGroup);
}
info.SwitchRanges.Add(Tuple.Create(startSwitchIndex, info.TargetGroups.Count));
}
private static void InsertIntoForeach(
CoverageInfo info, XElement node, LanguageSupport support, string relativePath) {
var startBranchIndex = info.Targets.Count;
var startBranchConditionIndex = info.TargetGroups.Count;
var analyzer = support.AstAnalyzer;
var transformer = support.AstTransformer;
var foreachNodes = analyzer.FindForeach(node);
foreach (var foreachNode in foreachNodes.ToList()) {
// ステートメントに測定用コードを埋め込む
var head = analyzer.FindForeachHead(foreachNode).First();
var tail = analyzer.FindForeachTail(foreachNode).First();
// 同じid( = count)を共有
var id = info.Targets.Count;
// Record(TrueOnly) _lastState = TrueOnly
// foreach() {
// Record(FalseOnly) ループ判定成立 (State |= FalseOnly)
// statement;
// Record(TrueOnly) _lastState = TrueOnly
// }
// Record(TrueOnly) ループ判定不成立 (State |= TrueOnly if _lastState == TrueOnly)
transformer.InsertStatementBefore(
foreachNode, id, TrueOnly, ElementType.DecisionAndCondition);
transformer.InsertStatementAfter(
head, id, FalseOnly, ElementType.DecisionAndCondition);
transformer.InsertStatementBefore(
tail, id, TrueOnly, ElementType.DecisionAndCondition);
transformer.InsertStatementAfter(
tail, id, TrueOnly, ElementType.DecisionAndCondition);
// カバレッジ情報を生成
var covElem = new ForeachCoverageElement(relativePath, foreachNode, support.Tagger);
info.Targets.Add(covElem);
var elementGroup = new CoverageElementGroup(covElem);
info.TargetGroups.Add(elementGroup);
}
info.BranchRanges.Add(Tuple.Create(startBranchIndex, info.Targets.Count));
info.BranchConditionRanges.Add(Tuple.Create(startBranchConditionIndex,
info.TargetGroups.Count));
}
private static void InsertIntoStatement(
CoverageInfo info, XElement root, LanguageSupport support, string relativePath) {
var statemetIndex = info.Targets.Count;
var nodes = support.AstAnalyzer.FindStatements(root);
foreach (var node in nodes.ToList()) {
// ステートメントに測定用コードを埋め込む
var posNode = support.AstAnalyzer.GetBaseElementForStatement(node);
support.AstTransformer.InsertStatementBefore(
posNode, info.Targets.Count, Done, ElementType.Statement);
// カバレッジ情報を生成
var covElem = new CoverageElement(relativePath, node, support.Tagger);
info.Targets.Add(covElem);
}
info.StatementRanges.Add(Tuple.Create(statemetIndex, info.Targets.Count));
}
private static void InsertIntoBranch(
CoverageInfo info, XElement node, LanguageSupport support, string relativePath) {
var branchNodes = support.AstAnalyzer.FindBranches(node);
var startBranchIndex = info.Targets.Count;
foreach (var branchNode in branchNodes.ToList()) {
support.AstTransformer.InsertPredicate(branchNode, info.Targets.Count,
ElementType.Decision);
// 条件分岐のカバレッジ情報を生成
var element = new CoverageElement(relativePath, branchNode, support.Tagger);
info.Targets.Add(element);
}
info.BranchRanges.Add(Tuple.Create(startBranchIndex, info.Targets.Count));
}
