uia 0.0.4 → 0.0.5

data/.rspec

@@ -0,0 +1 @@
+--format documentation --color

data/ChangeLog

@@ -0,0 +1,11 @@
+===	Verions 0.0.5 / 2012-10-16
+
+*	Enhancements
+	*	Pushed #find_element into the Uia module
+	*	Can locate elements by :id, :handle, :runtime_pid and :pid
+	*	Element now knows about :id,:control_type, :patterns, :handle and :runtime_id
+	*	Elements know about their :children and :descendants
+
+===	Version 0.0.4 / 2013-10-11
+Initial release with very limited support for finding an element and
+displaying various properties.

data/README.md

@@ -18,7 +18,24 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Getting started with `uia` is easy. Simply require `uia` and then include the `Uia` module wherever you would like to use it.
+
+```ruby
+require 'uia'
+
+include Uia
+
+main_window = find_element id: 'MainFormWindow'
+```
+
+### Finding Elements
+
+You can locate elements based on the following criteria:
+
+* `:id`         - find by their `AutomationId`
+* `:pid`        - find an element by their process id
+* `:handle`     - find an element by their native window handle
+* `:runtime_id` - find an element by their `RuntimeId` (i.e. `[42, 12345]`)
 
 ## Contributing
 

data/Rakefile

@@ -1 +1,6 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/ext/UiaDll/UIA.Helper/Element.cs

@@ -8,41 +8,58 @@ namespace UIA.Helper
     {
         private readonly AutomationElement _element;
 
+        protected Element()
+        {
+        }
+
         private Element(AutomationElement element)
         {
             _element = element;
         }
 
-        public int[] RuntimeId
+        public virtual int[] RuntimeId
         {
             get { return _element.GetRuntimeId(); }
         }
 
-        public string Name
+        public virtual string Name
         {
             get { return _element.Current.Name; }
         }
 
-        public int NativeWindowHandle
+        public virtual string Id
+        {
+            get { return _element.Current.AutomationId; }
+        }
+
+        public virtual int NativeWindowHandle
         {
             get { return _element.Current.NativeWindowHandle; }
         }
 
+        public virtual int ControlTypeId
+        {
+            get { return _element.Current.ControlType.Id; }
+        }
+
+        public virtual int[] SupportedPatternIds
+        {
+            get { return _element.GetSupportedPatterns().Select(x => x.Id).ToArray(); }
+        }
+
         public Element[] Children
         {
-            get
-            {
-                return _element.FindAll(TreeScope.Children, Condition.TrueCondition).Cast<AutomationElement>()
-                               .Select(x => new Element(x))
-                               .ToArray();
-            }
+            get { return Find(TreeScope.Children, Condition.TrueCondition); }
         }
 
         public Element[] ChildrenOf(AutomationProperty.Id id)
         {
-            return _element.FindAll(TreeScope.Children, AutomationProperty.From(id)).Cast<AutomationElement>()
-                           .Select(x => new Element(x))
-                           .ToArray();
+            return Find(TreeScope.Children, AutomationProperty.From(id));
+        }
+
+        public Element[] Descendants
+        {
+            get { return Find(TreeScope.Descendants, Condition.TrueCondition); }
         }
 
         public void MouseClick()
@@ -52,36 +69,39 @@ namespace UIA.Helper
 
         public static Element ById(string automationId)
         {
-            var foundElement = AutomationElement.RootElement.FindFirst(TreeScope.Descendants, new PropertyCondition(AutomationElement.AutomationIdProperty, automationId));
-            if (null == foundElement)
-            {
-                throw new ArgumentException(string.Format("An element with the id \"{0}\" was not found", automationId));
-            }
+            return FindFirst(new PropertyCondition(AutomationElement.AutomationIdProperty, automationId));
+        }
 
-            return new Element(foundElement);
+        public static Element ByProcessId(int processId)
+        {
+            return FindFirst(new PropertyCondition(AutomationElement.ProcessIdProperty, processId));
         }
 
         public static Element ByHandle(IntPtr windowHandle)
         {
-            var foundElement = AutomationElement.FromHandle(windowHandle);
-            if (null == foundElement)
-            {
-                throw new ArgumentException(string.Format("An element with the handle 0x{0:x} was not found", windowHandle.ToInt32()));
-            }
-
-            return new Element(foundElement);
+           return NullOr(AutomationElement.FromHandle(windowHandle));
         }
 
         public static Element ByRuntimeId(int[] runtimeId)
         {
-            var foundElement = AutomationElement.RootElement.FindFirst(TreeScope.Descendants, new PropertyCondition(AutomationElement.RuntimeIdProperty, runtimeId));
-            if (null == foundElement)
-            {
-                throw new ArgumentException(string.Format("An element with the runtime id \"{0}\" was not found",
-                                                          string.Join(", ", runtimeId.Select(x => x.ToString()))));
-            }
+            return FindFirst(new PropertyCondition(AutomationElement.RuntimeIdProperty, runtimeId));
+        }
 
-            return new Element(foundElement);
+        private Element[] Find(TreeScope scope, Condition condition)
+        {
+            return _element.FindAll(scope, condition).Cast<AutomationElement>()
+                           .Select(x => new Element(x))
+                           .ToArray();
+        }
+
+        private static Element FindFirst(Condition condition)
+        {
+            return NullOr(AutomationElement.RootElement.FindFirst(TreeScope.Descendants, condition));
+        }
+
+        private static Element NullOr(AutomationElement automationElement)
+        {
+            return null == automationElement ? null : new Element(automationElement);
         }
     }
 }

data/ext/UiaDll/UiaDll.Test/AssemblyInfo.cpp

@@ -0,0 +1,40 @@
+#include "stdafx.h"
+
+using namespace System;
+using namespace System::Reflection;
+using namespace System::Runtime::CompilerServices;
+using namespace System::Runtime::InteropServices;
+using namespace System::Security::Permissions;
+
+//
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly:AssemblyTitleAttribute("UiaDllTest")];
+[assembly:AssemblyDescriptionAttribute("")];
+[assembly:AssemblyConfigurationAttribute("")];
+[assembly:AssemblyCompanyAttribute("")];
+[assembly:AssemblyProductAttribute("UiaDllTest")];
+[assembly:AssemblyCopyrightAttribute("Copyright (c)  2013")];
+[assembly:AssemblyTrademarkAttribute("")];
+[assembly:AssemblyCultureAttribute("")];
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the value or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+
+[assembly:AssemblyVersionAttribute("1.0.*")];
+
+[assembly:ComVisible(false)];
+
+[assembly:CLSCompliantAttribute(true)];
+
+[assembly:SecurityPermission(SecurityAction::RequestMinimum, UnmanagedCode = true)];

data/ext/UiaDll/UiaDll.Test/ElementInformationTest.cpp

@@ -0,0 +1,89 @@
+#include "stdafx.h"
+#include "ElementStub.h"
+#include <ElementStructures.h>
+
+class ElementInformationTest : public ::testing::Test {
+public:
+  Element^ ElementWith(String^ name) {
+    return gcnew ElementStub(name);
+  }
+
+  Element^ ElementWith(...array<int>^ runtimeIds) {
+    return gcnew ElementStub("", runtimeIds);
+  }
+};
+
+TEST_F(ElementInformationTest, ItHasAnId)
+{
+  auto element = gcnew ElementStub("");
+  element->Id = "Expected Id";
+  ASSERT_STREQ("Expected Id", ElementInformation(element).id);
+}
+
+TEST_F(ElementInformationTest, ItCleansUpTheName)
+{
+  auto elementInformation = new ElementInformation(ElementWith("Some Name"));
+  delete elementInformation;
+}
+
+TEST_F(ElementInformationTest, ItCleansUpTheRuntimeId)
+{
+  auto elementInformation = new ElementInformation(ElementWith(46, 2));
+  delete elementInformation;
+}
+
+TEST_F(ElementInformationTest, ItHasTheName)
+{
+  ASSERT_STREQ("Expected Name", ElementInformation(gcnew ElementStub("Expected Name")).name);
+}
+
+TEST_F(ElementInformationTest, ItKnowsAboutTheRuntimeId)
+{
+  auto elementInformation = ElementInformation(gcnew ElementStub("", 0, 1, 2));
+  for(auto expected = 0; expected < 3; expected++) {
+    ASSERT_EQ(expected, elementInformation.runtimeId[expected]);
+  }
+
+  ASSERT_EQ(3, elementInformation.runtimeIdLength);
+}
+
+TEST_F(ElementInformationTest, ItKnowsTheWindowHandle)
+{
+  auto element = gcnew ElementStub("");
+  element->NativeWindowHandle = 12345;
+
+  ASSERT_EQ(ElementInformation(element).nativeWindowHandle, 12345);
+}
+
+TEST_F(ElementInformationTest, ItKnowsTheControlType)
+{
+  auto element = gcnew ElementStub("");
+  element->ControlTypeId = 1234;
+
+  ASSERT_EQ(1234, ElementInformation(element).controlTypeId);
+}
+
+TEST_F(ElementInformationTest, ItKnowsTheSupportedPatterns)
+{
+  auto element = gcnew ElementStub("");
+  element->SetPatterns(7, 5, 3);
+
+  auto elementInformation = ElementInformation(element);
+
+  const int expectedPatterns[] = {7, 5, 3};
+  ASSERT_THAT(expectedPatterns, ::testing::ElementsAreArray(elementInformation.patterns, elementInformation.patternsLength));
+}
+
+TEST_F(ElementInformationTest, ItCanBeUpdated)
+{
+  auto elementInformation = ElementInformation(gcnew ElementStub("Initial", 0));
+
+  auto updatedElement = gcnew ElementStub("Updated", 46, 2);
+  updatedElement->NativeWindowHandle = 123;
+  elementInformation.Update(updatedElement);
+
+  const int expectedId[] = {46, 2};
+  ASSERT_THAT(expectedId, ::testing::ElementsAreArray(elementInformation.runtimeId, elementInformation.runtimeIdLength));
+  ASSERT_STREQ("Updated", elementInformation.name);
+  ASSERT_EQ(123, elementInformation.nativeWindowHandle);
+}

data/ext/UiaDll/UiaDll.Test/ElementStub.h

@@ -0,0 +1,59 @@
+#include "stdafx.h"
+
+ref class ElementStub : Element
+{
+public:
+  ElementStub(String^ name, ...array<int>^ runtimeIds) : Element()
+  {
+    _name = name;
+    _runtimeIds = runtimeIds;
+    _patterns = gcnew array<int>(0);
+  }
+
+  virtual property String^ Name
+  {
+    String^ get() override { return _name; }
+    void set(String^ name) { _name = name; }
+  }
+
+  virtual property String^ Id
+  {
+    String^ get() override { return _id; }
+    void set(String^ value) override { _id = value; }
+  }
+
+  virtual property array<int>^ RuntimeId
+  {
+    array<int>^ get() override { return _runtimeIds; }
+  }
+
+  virtual property int NativeWindowHandle
+  {
+    int get() override { return _nativeWindowHandle; }
+    void set(int value) { _nativeWindowHandle = value; }
+  }
+
+  virtual property int ControlTypeId
+  {
+    int get() override { return _controlTypeId; }
+    void set(int value) override { _controlTypeId = value; }
+  }
+
+  virtual property array<int>^ SupportedPatternIds
+  {
+    array<int>^ get() override { return _patterns; }
+  }
+
+  void SetPatterns(... array<int>^ patterns)
+  {
+    _patterns = patterns;
+  }
+
+private:
+  String^ _name;
+  String^ _id;
+  array<int>^ _runtimeIds;
+  array<int>^ _patterns;
+  int _nativeWindowHandle;
+  int _controlTypeId;
+};

data/ext/UiaDll/UiaDll.Test/ElementsTest.cpp

@@ -0,0 +1,22 @@
+#include "stdafx.h"
+#include "ElementStub.h"
+#include <ElementStructures.h>
+
+class ElementsTest : public ::testing::Test {
+public:
+  array<Element^>^ ElementsWithNames(...array<String^>^ names) {
+    auto elements = gcnew array<Element^>(names->Length);
+    auto index = 0;
+    for each(auto name in names) {
+      elements[index++] = gcnew ElementStub(name);
+    }
+    return elements;
+  }
+};
+
+TEST_F(ElementsTest, ItCanBeInitialized)
+{
+  auto elements = Elements(ElementsWithNames("First", "Second"));
+  ASSERT_STREQ("First", elements.elements[0].name);
+  ASSERT_STREQ("Second", elements.elements[1].name);
+}

data/ext/UiaDll/UiaDll.Test/MemoryLeakDetector.h

@@ -0,0 +1,47 @@
+#pragma once
+
+/**
+ * @file
+ * @copyright (c) 2013 Stephan Brenner
+ * @license   This project is released under the MIT License.
+ *
+ * This file implements a main() function for Google Test that runs all tests
+ * and detects memory leaks.
+ */
+
+#include <iostream>
+#include <crtdbg.h>
+#include <gtest/gtest.h>
+
+using namespace std;
+using namespace testing;
+
+namespace testing
+{
+  class MemoryLeakDetector : public EmptyTestEventListener
+  {
+#ifdef _DEBUG
+  public:
+    virtual void OnTestStart(const TestInfo&)
+    {
+      _CrtMemCheckpoint(&memState_);
+    }
+
+    virtual void OnTestEnd(const TestInfo& test_info){
+      if(test_info.result()->Passed())
+      {
+        _CrtMemState stateNow, stateDiff;
+        _CrtMemCheckpoint(&stateNow);
+        int diffResult = _CrtMemDifference(&stateDiff, &memState_, &stateNow);
+        if (diffResult)
+        {
+          FAIL() << "Memory leak of " << stateDiff.lSizes[1] << " byte(s) detected.";
+        }
+      }
+    }
+
+  private:
+    _CrtMemState memState_;
+#endif // _DEBUG
+  };
+}