コード例 #1
0
        unsafe public void ProcessMessages(int APEPID, string AppDomainToLoadInto)
        {
            m_ManagedThreadId = Thread.CurrentThread.ManagedThreadId;
            try
            {
                AUTProcess = Process.GetCurrentProcess();
                string AUTProcessId = AUTProcess.Id.ToString();
                string APEProcessId = APEPID.ToString();

                // Set the thread name so its easy to find in the debugger
                Thread.CurrentThread.Name = "APE_" + APEProcessId + "_" + AppDomainToLoadInto + "_" + AUTProcessId;

                m_HandleMemoryMappedFileStringStore      = NM.CreateFileMapping((IntPtr)(NM.INVALID_HANDLE_VALUE), (IntPtr)0, NM.FileMapProtection.PageReadWrite, 0, StringSpaceBytes, APEProcessId + "_String_" + AppDomainToLoadInto + "_" + AUTProcessId);
                m_IntPtrMemoryMappedFileViewStringStore  = NM.MapViewOfFile(m_HandleMemoryMappedFileStringStore, NM.FileMapAccess.FileMapAllAccess, 0, 0, (UIntPtr)StringSpaceBytes);
                m_HandleMemoryMappedFileMessageStore     = NM.CreateFileMapping((IntPtr)(NM.INVALID_HANDLE_VALUE), (IntPtr)0, NM.FileMapProtection.PageReadWrite, 0, (uint)sizeof(MessageStore), APEProcessId + "_Message_" + AppDomainToLoadInto + "_" + AUTProcessId);
                m_IntPtrMemoryMappedFileViewMessageStore = NM.MapViewOfFile(m_HandleMemoryMappedFileMessageStore, NM.FileMapAccess.FileMapAllAccess, 0, 0, (UIntPtr)sizeof(MessageStore));
                m_PtrMessageStore = (MessageStore *)m_IntPtrMemoryMappedFileViewMessageStore.ToPointer();

                m_eventIPC = new EventWaitHandle(false, EventResetMode.AutoReset, APEProcessId + "_EventIPC_" + AppDomainToLoadInto + "_" + AUTProcessId);

                Side = EventSet.AUT;
                try
                {
                    ApeProcess = Process.GetProcessById(APEPID);
                }
                catch
                {
                }

                // Setup the hook procedures
                SetupmouseHelperHooks();
                EnumThreadProcedue = new NM.EnumWindow(EnumThreadCallback);

                // Setup the delegates
                m_GetWPFHandleAndNameAndTitleDelegater = new GetWPFHandleAndNameAndTitleDelegate(GetWPFHandleAndNameAndTitle);
                m_ConvertTypeDelegater = new ConvertTypeDelegate(Cast);
                m_GetTextDelegater     = new GetTextDelegate(GetText);
                m_GetAccessibilityObjectNameDelegater = new GetAccessibilityObjectNameDelegate(GetAccessibilityObjectName);
                SetupSentinelGridsHelperDelegates();
                SetupFlexgridHelperDelegates();
                SetupComHelperDelegates();
                SetupGridControlHelperDelegates();
                SetupFormHelperDelegates();
                SetupDictionaryHelperDelegates();
                SetupDataGridViewHelperDelegates();

                //Process all the messages
                while (true)
                {
                    WaitForMessages(EventSet.AUT);
                    if (m_Abort)
                    {
                        RemoveFileMapping();
                        break;
                    }

                    string result           = null;
                    int    messageNumber    = -1;
                    int    numberOfMessages = -1;

                    try
                    {
                        numberOfMessages = m_PtrMessageStore->NumberOfMessages;
                        m_PtrMessageStore->NumberOfMessages = 0;
                        m_StringStoreOffset = 0;

                        for (messageNumber = 1; messageNumber <= numberOfMessages; messageNumber++)
                        {
                            Message *ptrMessage = (Message *)(m_IntPtrMemoryMappedFileViewMessageStore + ((messageNumber - 1) * m_SizeOfMessage));

                            DebugLogging.WriteLog("Processing message " + ptrMessage->Action.ToString());
                            //get the message action:
                            switch (ptrMessage->Action)
                            {
                            case MessageAction.GetListViewGroupRectangle:
                                GetListViewGroupRectangle(messageNumber);
                                break;

                            case MessageAction.GetListViewItemRectangle:
                                GetListViewItemRectangle(messageNumber);
                                break;

                            case MessageAction.ControlExists:
                                string findText = Find(messageNumber, 0);
                                if (findText != null)
                                {
                                    ControlIdentifier newIdentifier = new ControlIdentifier();
                                    AddIdentifierMessage(newIdentifier);
                                }
                                break;

                            case MessageAction.Find:
                                result = Find(messageNumber, m_TimeOut);
                                break;

                            case MessageAction.RefindByHandle:
                                RefindByHandle(messageNumber);
                                break;

                            case MessageAction.RefindByUniqueId:
                                RefindByUniqueId(messageNumber);
                                break;

                            case MessageAction.ReflectGet:
                                Reflect(messageNumber);
                                break;

                            case MessageAction.ConvertType:
                                ConvertType(messageNumber);
                                break;

                            case MessageAction.SentinelGridsGetUnderlyingGrid:
                                SentinelGridsGetUnderlyingGrid(ptrMessage);
                                break;

                            case MessageAction.ReflectPoll:
                                ReflectPoll(messageNumber);
                                break;

                            case MessageAction.GetResult:
                                GetResult(messageNumber);
                                break;

                            case MessageAction.AddMouseHook:
                                AddMouseHook(ptrMessage, messageNumber);
                                break;

                            case MessageAction.RemoveMouseHook:
                                RemoveMouseHook(ptrMessage, messageNumber);
                                break;

                            case MessageAction.WaitForMouseState:
                                WaitForMouseState(ptrMessage, messageNumber);
                                break;

                            case MessageAction.SetTimeOuts:
                                SetTimeOuts(messageNumber);
                                break;

                            case MessageAction.GetTitleBarItemRectangle:
                                GetTitleBarItemRectangle(ptrMessage, messageNumber);
                                break;

                            case MessageAction.GarbageCollect:
                                GarbageCollect(ptrMessage, messageNumber);
                                break;

                            case MessageAction.GetContextMenuStrip:
                                GetContextMenuStrip(messageNumber);
                                break;

                            case MessageAction.GetAppDomains:
                                GetAppDomains(messageNumber);
                                break;

                            case MessageAction.GetRecognisedType:
                                GetRecognisedType(messageNumber);
                                break;

                            case MessageAction.GetApeTypeFromType:
                                GetApeTypeFromType(messageNumber);
                                break;

                            case MessageAction.GetApeTypeFromObject:
                                GetApeTypeFromObject(messageNumber);
                                break;

                            // Flexgrid helper methods
                            case MessageAction.FlexgridGetCellRangeBackColourName:
                                FlexgridGetCellRange(ptrMessage, CellProperty.BackColourName);
                                break;

                            case MessageAction.FlexgridGetCellRangeForeColourName:
                                FlexgridGetCellRange(ptrMessage, CellProperty.ForeColourName);
                                break;

                            case MessageAction.FlexgridGetCellRangeDataType:
                                FlexgridGetCellRange(ptrMessage, CellProperty.DataType);
                                break;

                            case MessageAction.FlexgridGetCellRangeCheckBox:
                                FlexgridGetCellRange(ptrMessage, CellProperty.CheckBox);
                                break;

                            case MessageAction.FlexgridGetCellRangeImage:
                                FlexgridGetCellRange(ptrMessage, CellProperty.Image);
                                break;

                            case MessageAction.FlexgridGetCellRangeBackgroundImage:
                                FlexgridGetCellRange(ptrMessage, CellProperty.BackgroundImage);
                                break;

                            case MessageAction.FlexgridGetAllColumnsHidden:
                                FlexgridGetAllColumnsHidden(ptrMessage);
                                break;

                            case MessageAction.FlexgridGetAllRowsHidden:
                                FlexgridGetAllRowsHidden(ptrMessage);
                                break;

                            case MessageAction.FlexgridGetAllColumnsWidth:
                                FlexgridGetAllColumnsWidth(ptrMessage);
                                break;

                            case MessageAction.FlexgridGetAllRowsHeight:
                                FlexgridGetAllRowsHeight(ptrMessage);
                                break;

                            case MessageAction.GridControlGetTitleRows:
                                GridControlGetTitleRows(ptrMessage);
                                break;

                            case MessageAction.GridControlGetTitleRowCount:
                                GridControlGetTitleRowCount(ptrMessage);
                                break;

                            case MessageAction.GridControlGetAllColumnsHidden:
                                GridControlGetAllColumnsVisible(ptrMessage);
                                break;

                            case MessageAction.GetDateTimePickerCheckboxRectangle:
                                GetDateTimePickerCheckboxRectangle(ptrMessage, messageNumber);
                                break;

                            case MessageAction.GetDateTimePickerButtonRectangle:
                                GetDateTimePickerButtonRectangle(ptrMessage, messageNumber);
                                break;

                            case MessageAction.ScrollControlIntoView:
                                ScrollControlIntoView(ptrMessage, messageNumber);
                                break;

                            case MessageAction.PeakMessage:
                                PeakMessage(ptrMessage, messageNumber);
                                break;

                            case MessageAction.SetFocus:
                                SetFocus(ptrMessage, messageNumber);
                                break;

                            case MessageAction.SetFocusAsync:
                                SetFocusAsync(ptrMessage, messageNumber);
                                break;

                            case MessageAction.GridControlEnsureTitleCellVisible:
                                GridControlEnsureTitleCellVisible(ptrMessage);
                                break;

                            case MessageAction.DictionaryContainsKey:
                                DictionaryContainsKey(ptrMessage);
                                break;

                            case MessageAction.AddMouseClickHandler:
                                AddMouseClickHandler(ptrMessage);
                                break;

                            case MessageAction.WaitForAndRemoveMouseClickHandler:
                                WaitForAndRemoveMouseClickHandler(ptrMessage);
                                break;

                            case MessageAction.RemoveMouseClickHandler:
                                RemoveMouseClickHandler(ptrMessage);
                                break;

                            case MessageAction.AddFlexgridCellChangedHandler:
                                AddFlexgridCellChangedHandler(ptrMessage);
                                break;

                            case MessageAction.WaitForAndRemoveFlexgridCellChangedHandler:
                                WaitForAndRemoveFlexgridCellChangedHandler(ptrMessage);
                                break;

                            case MessageAction.AddFlexgridAfterRowColChangeHandler:
                                AddFlexgridAfterRowColChangeHandler(ptrMessage);
                                break;

                            case MessageAction.WaitForAndRemoveFlexgridAfterRowColChangeHandler:
                                WaitForAndRemoveFlexgridAfterRowColChangeHandler(ptrMessage);
                                break;

                            case MessageAction.RemoveFlexgridAfterRowColChangeHandler:
                                RemoveFlexgridAfterRowColChangeHandler(ptrMessage);
                                break;

                            case MessageAction.AddGenericWalkerSelectedHandler:
                                AddGenericWalkerSelectedHandler(ptrMessage);
                                break;

                            case MessageAction.WaitForAndRemoveGenericWalkerSelectedHandler:
                                WaitForAndRemoveGenericWalkerSelectedHandler(ptrMessage);
                                break;

                            case MessageAction.RemoveGenericWalkerSelectedHandler:
                                RemoveGenericWalkerSelectedHandler(ptrMessage);
                                break;

                            case MessageAction.VisualStyleSupported:
                                VisualStyleSupported(ptrMessage, messageNumber);
                                break;

                            case MessageAction.DataGridViewShowCell:
                                DataGridViewShowCell(ptrMessage);
                                break;

                            case MessageAction.GetToolTip:
                                GetToolTip(ptrMessage, messageNumber);
                                break;

                            case MessageAction.DumpActiveX:
                                DumpActiveX(ptrMessage, messageNumber);
                                break;

                            case MessageAction.FlexgridGetNodeCollapsedState:
                                FlexgridGetNodeCollapsedState(ptrMessage);
                                break;

                            case MessageAction.GetTypeInformationActiveX:
                                GetTypeInformationActiveX(ptrMessage);
                                break;

                            case MessageAction.GetTabRect:
                                GetTabRect(ptrMessage);
                                break;

                            case MessageAction.GetInvokeFormActiveX:
                                GetInvokeFormActiveX(ptrMessage, messageNumber);
                                break;

                            case MessageAction.GetComboBoxExItemText:
                                GetComboBoxExItemText(ptrMessage, messageNumber);
                                break;

                            case MessageAction.WaitForMouseMove:
                                WaitForMouseMove(ptrMessage, messageNumber);
                                break;

                            case MessageAction.AddToolStripItemEnteredHandler:
                                AddToolStripItemEnteredHandler(ptrMessage);
                                break;

                            case MessageAction.WaitForAndRemoveToolStripItemEnteredHandler:
                                WaitForAndRemoveToolStripItemEnteredHandler(ptrMessage);
                                break;

                            case MessageAction.DumpControl:
                                DumpControl(ptrMessage, messageNumber);
                                break;

                            case MessageAction.FlexgridGetCellRangeTextDisplay:
                                FlexgridGetCellRange(ptrMessage, CellProperty.TextDisplay);
                                break;

                            case MessageAction.FlexgridGetCellRangeFontStyle:
                                FlexgridGetCellRange(ptrMessage, CellProperty.FontStyle);
                                break;

                            case MessageAction.FlexgridGetCellBackgroundImage:
                                FlexgridGetCellBackgroundImage(ptrMessage);
                                break;

                            default:
                                throw new Exception("Unknown action for message " + messageNumber.ToString() + " : " + ptrMessage->Action.ToString());
                            }

                            if (result != null)
                            {
                                break;
                            }
                        }

                        if (result == null)
                        {
                            AddResultMessage(MessageResult.Success);
                        }
                    }
                    catch (Exception ex)
                    {
                        result  = "Message " + messageNumber.ToString() + " of " + numberOfMessages + " failed:\r\n";
                        result += ex.GetType().Name + " " + ex.Message + "\r\n" + ex.StackTrace;
                        if (ex.InnerException != null)
                        {
                            //TODO make this better?
                            result += "\r\n" + ex.InnerException.GetType().Name + " " + ex.InnerException.Message + "\r\n" + ex.InnerException.StackTrace;
                        }
                    }

                    if (result != null)
                    {
                        //clean up all the messages
                        for (messageNumber = 1; messageNumber <= MessageStore.MaxMessages; messageNumber++)
                        {
                            Message *ptrMessage = (Message *)(m_IntPtrMemoryMappedFileViewMessageStore + ((messageNumber - 1) * m_SizeOfMessage));
                            CleanUpMessage(ptrMessage);
                        }

                        m_PtrMessageStore->NumberOfMessages = 0;
                        m_StringStoreOffset = 0;

                        AddResultMessage(MessageResult.Failure, result);
                    }

                    //clear the data stores so we don't hold any references to objects in the AUT
                    //which would stop them being garbage collected
                    if (tempStore0ReleaseComObject)
                    {
                        Marshal.ReleaseComObject(tempStore0);
                        tempStore0ReleaseComObject = false;
                    }
                    tempStore0 = null;
                    if (tempStore1ReleaseComObject)
                    {
                        Marshal.ReleaseComObject(tempStore1);
                        tempStore1ReleaseComObject = false;
                    }
                    tempStore1 = null;
                    if (tempStore2ReleaseComObject)
                    {
                        Marshal.ReleaseComObject(tempStore2);
                        tempStore2ReleaseComObject = false;
                    }
                    tempStore2 = null;
                    if (tempStore3ReleaseComObject)
                    {
                        Marshal.ReleaseComObject(tempStore3);
                        tempStore3ReleaseComObject = false;
                    }
                    tempStore3 = null;
                    if (tempStore4ReleaseComObject)
                    {
                        Marshal.ReleaseComObject(tempStore4);
                        tempStore4ReleaseComObject = false;
                    }
                    tempStore4 = null;
                    if (tempStore5ReleaseComObject)
                    {
                        Marshal.ReleaseComObject(tempStore5);
                        tempStore5ReleaseComObject = false;
                    }
                    tempStore5 = null;
                    if (tempStore6ReleaseComObject)
                    {
                        Marshal.ReleaseComObject(tempStore6);
                        tempStore6ReleaseComObject = false;
                    }
                    tempStore6 = null;
                    if (tempStore7ReleaseComObject)
                    {
                        Marshal.ReleaseComObject(tempStore7);
                        tempStore7ReleaseComObject = false;
                    }
                    tempStore7 = null;
                    if (tempStore8ReleaseComObject)
                    {
                        Marshal.ReleaseComObject(tempStore8);
                        tempStore8ReleaseComObject = false;
                    }
                    tempStore8 = null;
                    if (tempStore9ReleaseComObject)
                    {
                        Marshal.ReleaseComObject(tempStore9);
                        tempStore9ReleaseComObject = false;
                    }
                    tempStore9 = null;

                    //send back our response
                    SendMessages(EventSet.AUT);
                }
            }
            catch (Exception ex)
            {
                TextWriter log = File.AppendText(Environment.GetEnvironmentVariable("TEMP") + @"\critical.log");
                log.WriteLine(DateTime.Now.ToString() + "\t" + ex.Message);
                log.WriteLine(DateTime.Now.ToString() + "\t" + ex.StackTrace);
                log.Close();
                throw;
            }
        }
コード例 #2
0
        /// <summary>
        /// Starts the debug string capture
        /// <param name="filename">The file of the zipfile to capture the debug string output in</param>
        /// <param name="process">The process to filter the debug string output for</param>
        /// </summary>
        public static void StartCapture(string filename, Process process)
        {
            m_Filename = filename;

            if (process == null)
            {
                m_PID = 0;
            }
            else
            {
                m_PID = process.Id;
            }

            lock (m_SyncRoot)
            {
                if (m_Capturer != null)
                {
                    throw new ApplicationException("DebugString capture is already started");
                }

                // Check for multiple instances
                m_Mutex = new Mutex(false, typeof(DebugString).Namespace, out bool createdNew);
                if (!createdNew)
                {
                    throw new ApplicationException("There is already an instance running");
                }

                //NM.SECURITY_ATTRIBUTES sa = new NM.SECURITY_ATTRIBUTES();
                //sa.lpSecurityDescriptor = IntPtr.Zero;
                IntPtr sa = IntPtr.Zero;

                // Create the event for slot 'DBWIN_BUFFER_READY'
                m_AckEvent = NM.CreateEvent(sa, false, false, "DBWIN_BUFFER_READY");
                if (m_AckEvent == IntPtr.Zero)
                {
                    throw CreateApplicationException("Failed to create event 'DBWIN_BUFFER_READY'");
                }

                // Create the event for slot 'DBWIN_DATA_READY'
                m_ReadyEvent = NM.CreateEvent(sa, false, false, "DBWIN_DATA_READY");
                if (m_ReadyEvent == IntPtr.Zero)
                {
                    throw CreateApplicationException("Failed to create event 'DBWIN_DATA_READY'");
                }

                // Get a handle to the readable shared memory at slot 'DBWIN_BUFFER'.
                m_SharedFile = NM.CreateFileMapping(new IntPtr(-1), sa, NM.PageProtection.ReadWrite, 0, 4096, "DBWIN_BUFFER");
                if (m_SharedFile == IntPtr.Zero)
                {
                    throw CreateApplicationException("Failed to create a file mapping to slot 'DBWIN_BUFFER'");
                }

                // Create a view for this file mapping so we can access it
                m_SharedMem = NM.MapViewOfFile(m_SharedFile, NM.FileMapAccess.FileMapRead, 0, 0, new IntPtr(512));
                if (m_SharedMem == IntPtr.Zero)
                {
                    throw CreateApplicationException("Failed to create a mapping view for slot 'DBWIN_BUFFER'");
                }

                //create the file
                m_tw = new StreamWriter(Path.GetDirectoryName(m_Filename) + @"\" + Path.GetFileNameWithoutExtension(m_Filename) + @".txt");

                // Start a new thread where we can capture the output
                // of OutputDebugString calls so we don't block here.
                m_Capturer = new Thread(new ThreadStart(Capture));
                m_Capturer.Start();
            }
        }