uia 0.0.4 → 0.0.5

data/ext/UiaDll/UiaDll.Test/gtest/include/gtest/internal/gtest-type-util.h.pump

@@ -0,0 +1,297 @@
+$$ -*- mode: c++; -*-
+$var n = 50  $$ Maximum length of type lists we want to support.
+// Copyright 2008 Google Inc.
+// All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Type utilities needed for implementing typed and type-parameterized
+// tests.  This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
+//
+// Currently we support at most $n types in a list, and at most $n
+// type-parameterized tests in one type-parameterized test case.
+// Please contact googletestframework@googlegroups.com if you need
+// more.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+
+#include "gtest/internal/gtest-port.h"
+
+// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
+// libstdc++ (which is where cxxabi.h comes from).
+# if GTEST_HAS_CXXABI_H_
+#  include <cxxabi.h>
+# elif defined(__HP_aCC)
+#  include <acxx_demangle.h>
+# endif  // GTEST_HASH_CXXABI_H_
+
+namespace testing {
+namespace internal {
+
+// GetTypeName<T>() returns a human-readable name of type T.
+// NB: This function is also used in Google Mock, so don't move it inside of
+// the typed-test-only section below.
+template <typename T>
+std::string GetTypeName() {
+# if GTEST_HAS_RTTI
+
+  const char* const name = typeid(T).name();
+#  if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
+  int status = 0;
+  // gcc's implementation of typeid(T).name() mangles the type name,
+  // so we have to demangle it.
+#   if GTEST_HAS_CXXABI_H_
+  using abi::__cxa_demangle;
+#   endif  // GTEST_HAS_CXXABI_H_
+  char* const readable_name = __cxa_demangle(name, 0, 0, &status);
+  const std::string name_str(status == 0 ? readable_name : name);
+  free(readable_name);
+  return name_str;
+#  else
+  return name;
+#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
+
+# else
+
+  return "<type>";
+
+# endif  // GTEST_HAS_RTTI
+}
+
+#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
+// type.  This can be used as a compile-time assertion to ensure that
+// two types are equal.
+
+template <typename T1, typename T2>
+struct AssertTypeEq;
+
+template <typename T>
+struct AssertTypeEq<T, T> {
+  typedef bool type;
+};
+
+// A unique type used as the default value for the arguments of class
+// template Types.  This allows us to simulate variadic templates
+// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
+// support directly.
+struct None {};
+
+// The following family of struct and struct templates are used to
+// represent type lists.  In particular, TypesN<T1, T2, ..., TN>
+// represents a type list with N types (T1, T2, ..., and TN) in it.
+// Except for Types0, every struct in the family has two member types:
+// Head for the first type in the list, and Tail for the rest of the
+// list.
+
+// The empty type list.
+struct Types0 {};
+
+// Type lists of length 1, 2, 3, and so on.
+
+template <typename T1>
+struct Types1 {
+  typedef T1 Head;
+  typedef Types0 Tail;
+};
+
+$range i 2..n
+
+$for i [[
+$range j 1..i
+$range k 2..i
+template <$for j, [[typename T$j]]>
+struct Types$i {
+  typedef T1 Head;
+  typedef Types$(i-1)<$for k, [[T$k]]> Tail;
+};
+
+
+]]
+
+}  // namespace internal
+
+// We don't want to require the users to write TypesN<...> directly,
+// as that would require them to count the length.  Types<...> is much
+// easier to write, but generates horrible messages when there is a
+// compiler error, as gcc insists on printing out each template
+// argument, even if it has the default value (this means Types<int>
+// will appear as Types<int, None, None, ..., None> in the compiler
+// errors).
+//
+// Our solution is to combine the best part of the two approaches: a
+// user would write Types<T1, ..., TN>, and Google Test will translate
+// that to TypesN<T1, ..., TN> internally to make error messages
+// readable.  The translation is done by the 'type' member of the
+// Types template.
+
+$range i 1..n
+template <$for i, [[typename T$i = internal::None]]>
+struct Types {
+  typedef internal::Types$n<$for i, [[T$i]]> type;
+};
+
+template <>
+struct Types<$for i, [[internal::None]]> {
+  typedef internal::Types0 type;
+};
+
+$range i 1..n-1
+$for i [[
+$range j 1..i
+$range k i+1..n
+template <$for j, [[typename T$j]]>
+struct Types<$for j, [[T$j]]$for k[[, internal::None]]> {
+  typedef internal::Types$i<$for j, [[T$j]]> type;
+};
+
+]]
+
+namespace internal {
+
+# define GTEST_TEMPLATE_ template <typename T> class
+
+// The template "selector" struct TemplateSel<Tmpl> is used to
+// represent Tmpl, which must be a class template with one type
+// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
+// as the type Tmpl<T>.  This allows us to actually instantiate the
+// template "selected" by TemplateSel<Tmpl>.
+//
+// This trick is necessary for simulating typedef for class templates,
+// which C++ doesn't support directly.
+template <GTEST_TEMPLATE_ Tmpl>
+struct TemplateSel {
+  template <typename T>
+  struct Bind {
+    typedef Tmpl<T> type;
+  };
+};
+
+# define GTEST_BIND_(TmplSel, T) \
+  TmplSel::template Bind<T>::type
+
+// A unique struct template used as the default value for the
+// arguments of class template Templates.  This allows us to simulate
+// variadic templates (e.g. Templates<int>, Templates<int, double>,
+// and etc), which C++ doesn't support directly.
+template <typename T>
+struct NoneT {};
+
+// The following family of struct and struct templates are used to
+// represent template lists.  In particular, TemplatesN<T1, T2, ...,
+// TN> represents a list of N templates (T1, T2, ..., and TN).  Except
+// for Templates0, every struct in the family has two member types:
+// Head for the selector of the first template in the list, and Tail
+// for the rest of the list.
+
+// The empty template list.
+struct Templates0 {};
+
+// Template lists of length 1, 2, 3, and so on.
+
+template <GTEST_TEMPLATE_ T1>
+struct Templates1 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates0 Tail;
+};
+
+$range i 2..n
+
+$for i [[
+$range j 1..i
+$range k 2..i
+template <$for j, [[GTEST_TEMPLATE_ T$j]]>
+struct Templates$i {
+  typedef TemplateSel<T1> Head;
+  typedef Templates$(i-1)<$for k, [[T$k]]> Tail;
+};
+
+
+]]
+
+// We don't want to require the users to write TemplatesN<...> directly,
+// as that would require them to count the length.  Templates<...> is much
+// easier to write, but generates horrible messages when there is a
+// compiler error, as gcc insists on printing out each template
+// argument, even if it has the default value (this means Templates<list>
+// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler
+// errors).
+//
+// Our solution is to combine the best part of the two approaches: a
+// user would write Templates<T1, ..., TN>, and Google Test will translate
+// that to TemplatesN<T1, ..., TN> internally to make error messages
+// readable.  The translation is done by the 'type' member of the
+// Templates template.
+
+$range i 1..n
+template <$for i, [[GTEST_TEMPLATE_ T$i = NoneT]]>
+struct Templates {
+  typedef Templates$n<$for i, [[T$i]]> type;
+};
+
+template <>
+struct Templates<$for i, [[NoneT]]> {
+  typedef Templates0 type;
+};
+
+$range i 1..n-1
+$for i [[
+$range j 1..i
+$range k i+1..n
+template <$for j, [[GTEST_TEMPLATE_ T$j]]>
+struct Templates<$for j, [[T$j]]$for k[[, NoneT]]> {
+  typedef Templates$i<$for j, [[T$j]]> type;
+};
+
+]]
+
+// The TypeList template makes it possible to use either a single type
+// or a Types<...> list in TYPED_TEST_CASE() and
+// INSTANTIATE_TYPED_TEST_CASE_P().
+
+template <typename T>
+struct TypeList {
+  typedef Types1<T> type;
+};
+
+
+$range i 1..n
+template <$for i, [[typename T$i]]>
+struct TypeList<Types<$for i, [[T$i]]> > {
+  typedef typename Types<$for i, [[T$i]]>::type type;
+};
+
+#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_

data/ext/UiaDll/UiaDll.Test/resource.h

@@ -0,0 +1,3 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by app.rc

data/ext/UiaDll/UiaDll.Test/stdafx.cpp

@@ -0,0 +1,7 @@
+// stdafx.cpp : source file that includes just the standard includes
+// UiaDll.Test.pch will be the pre-compiled header
+// stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"
+
+

data/ext/UiaDll/UiaDll.Test/stdafx.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <gtest\gtest.h>
+#include <gmock\gmock.h>
+
+using namespace System;
+using namespace UIA::Helper;

data/ext/UiaDll/UiaDll.sln

@@ -5,6 +5,11 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "UiaDll", "UiaDll\UiaDll.vcx
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UIA.Helper", "UIA.Helper\UIA.Helper.csproj", "{C2D567A8-B059-41A8-B9F5-FF4F8F961C1F}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "UiaDll.Test", "UiaDll.Test\UiaDll.Test.vcxproj", "{E83CF3F7-74C6-4333-89E3-36C6297F0A06}"
+	ProjectSection(ProjectDependencies) = postProject
+		{16531A20-39FB-4BDB-8F1C-E2D619BBCF58} = {16531A20-39FB-4BDB-8F1C-E2D619BBCF58}
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -35,6 +40,16 @@ Global
 		{C2D567A8-B059-41A8-B9F5-FF4F8F961C1F}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{C2D567A8-B059-41A8-B9F5-FF4F8F961C1F}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{C2D567A8-B059-41A8-B9F5-FF4F8F961C1F}.Release|Win32.ActiveCfg = Release|Any CPU
+		{E83CF3F7-74C6-4333-89E3-36C6297F0A06}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{E83CF3F7-74C6-4333-89E3-36C6297F0A06}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{E83CF3F7-74C6-4333-89E3-36C6297F0A06}.Debug|Mixed Platforms.Build.0 = Debug|Win32
+		{E83CF3F7-74C6-4333-89E3-36C6297F0A06}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E83CF3F7-74C6-4333-89E3-36C6297F0A06}.Debug|Win32.Build.0 = Debug|Win32
+		{E83CF3F7-74C6-4333-89E3-36C6297F0A06}.Release|Any CPU.ActiveCfg = Release|Win32
+		{E83CF3F7-74C6-4333-89E3-36C6297F0A06}.Release|Mixed Platforms.ActiveCfg = Debug|Win32
+		{E83CF3F7-74C6-4333-89E3-36C6297F0A06}.Release|Mixed Platforms.Build.0 = Debug|Win32
+		{E83CF3F7-74C6-4333-89E3-36C6297F0A06}.Release|Win32.ActiveCfg = Release|Win32
+		{E83CF3F7-74C6-4333-89E3-36C6297F0A06}.Release|Win32.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

data/ext/UiaDll/UiaDll/ArrayHelper.h

@@ -2,7 +2,25 @@
 ref class ArrayHelper
 {
 public:
-  static array<int>^ ToArray(const int items[], const int length);
-  static int* FromArray(array<int>^ items);
+  static array<int>^ ToArray(const int items[], const int length)
+  {
+    auto managedItems = gcnew array<int>(length);
+    for(auto index = 0; index < length; ++index) {
+      managedItems[index] = items[index];
+    }
+    return managedItems;
+  }
+
+  static int* FromArray(array<int>^ items)
+  {
+    auto unmanagedArray = new int[items->Length];
+
+    auto index = 0;
+    for each(auto item in items) {
+      unmanagedArray[index++] = item;
+    }
+
+    return unmanagedArray;
+  }
 };
 

data/ext/UiaDll/UiaDll/ElementMethods.cpp

@@ -29,6 +29,16 @@ extern "C" {
     return NULL;
   }
 
+  __declspec(dllexport) PElementInformation Element_FindByProcessId(const int processId, char* errorInfo, const int errorLength) {
+    try {
+      return new ElementInformation(Element::ByProcessId(processId));
+    } catch(Exception^ error) {
+      StringHelper::CopyToUnmanagedString(error->Message, errorInfo, errorLength);
+    }
+
+    return NULL;
+  }
+
   __declspec(dllexport) PElementInformation Element_FindByHandle(HWND windowHandle, char* errorInfo, const int errorLength) {
     try {
       return new ElementInformation(Element::ByHandle(IntPtr(windowHandle)));
@@ -63,6 +73,14 @@ extern "C" {
     }
   }
 
+  __declspec(dllexport) PElements Element_Descendants(PElementInformation parentElement, char* errorInfo, const int errorLength) {
+    try {
+      return new Elements(Find(parentElement)->Descendants);
+    } catch(Exception^ error) {
+      StringHelper::CopyToUnmanagedString(error->Message, errorInfo, errorLength);
+    }
+  }
+
   __declspec(dllexport) void Element_Click(PElementInformation element, char* errorInfo, const int errorLength) {
     try {
       Find(element)->MouseClick();

data/ext/UiaDll/UiaDll/ElementStructures.h

@@ -1,27 +1,43 @@
-#include "Stdafx.h"
+#pragma once
+#include "ArrayHelper.h"
+#include "StringHelper.h"
 
 typedef struct _ElementInformation {
   int nativeWindowHandle;
   int* runtimeId;
   int runtimeIdLength;
   char* name;
+  int controlTypeId;
+  int* patterns;
+  int patternsLength;
+  char* id;
 
-  _ElementInformation() : name(NULL), nativeWindowHandle(0) {}
+  _ElementInformation() : name(NULL), nativeWindowHandle(0), runtimeId(NULL), patterns(NULL), id(NULL) {}
 
-  _ElementInformation(Element^ element) : name(NULL), nativeWindowHandle(0) {
-    this->name = StringHelper::ToUnmanaged(element->Name);
-    this->nativeWindowHandle = element->NativeWindowHandle;
+  _ElementInformation(Element^ element) : name(NULL), nativeWindowHandle(0), runtimeId(NULL), patterns(NULL), id(NULL) {
+    Update(element);
+  }
+
+  void Update(Element^ element) {
+    Reset();
+    id = StringHelper::ToUnmanaged(element->Id);
+    name = StringHelper::ToUnmanaged(element->Name);
+    nativeWindowHandle = element->NativeWindowHandle;
     runtimeId = ArrayHelper::FromArray(element->RuntimeId);
     runtimeIdLength = element->RuntimeId->Length;
+    controlTypeId = element->ControlTypeId;
+    patterns = ArrayHelper::FromArray(element->SupportedPatternIds);
+    patternsLength = element->SupportedPatternIds->Length;
   }
 
   ~_ElementInformation() {
-    if( NULL != name) {
-      delete[] name;
-    }
-    if( NULL != runtimeId ) {
-      delete[] runtimeId;
-    }
+    Reset();
+  }
+
+private:
+  void Reset() {
+    delete[] name; delete[] runtimeId; delete[] patterns; delete[] id;
+    name = NULL; runtimeId = NULL; patterns = NULL; id = NULL;
   }
 
 } ElementInformation, *PElementInformation;
@@ -30,23 +46,19 @@ typedef struct _Elements {
   int length;
   ElementInformation* elements;
 
-  _Elements(array<Element^>^ elements) {
+  _Elements() : length(0), elements(NULL) {}
+
+  _Elements(array<Element^>^ elements) : elements(NULL) {
     length = elements->Length;
-    this->elements = NULL;
-    if( length > 0 ) {
-      this->elements = new ElementInformation[length];
-
-      auto index = 0;
-      for each(Element^ child in elements) {
-        auto element = new ElementInformation(child);
-        memcpy(&this->elements[index++], element, sizeof(ElementInformation));
-      }
+    if( length > 0 ) this->elements = new ElementInformation[length];
+
+    auto index = 0;
+    for each(auto element in elements) {
+      this->elements[index++].Update(element);
     }
   }
 
   ~_Elements() {
-    for(auto index = 0; index < length; ++index) {
-      elements[index].~_ElementInformation();
-    }
+    delete[] elements;
   }
 } Elements, *PElements;