smart_monkey 0.1

data/lib/ui-auto-monkey/custom.js

@@ -0,0 +1,73 @@
+#import "UIAutoMonkey.js"
+#import "handler/buttonHandler.js"
+#import "handler/wbScrollViewButtonHandler.js"
+#import "tuneup/tuneup.js"
+
+// Configure the monkey: use the default configuration but a bit tweaked
+monkey = new UIAutoMonkey();
+monkey.config.numberOfEvents = 50; // turn off to make clear that we want minutes
+monkey.config.delayBetweenEvents = 0.05;
+monkey.config.eventWeights = {
+			tap: 100,
+			drag: 10,
+			flick: 10,
+			orientation: 1,
+			lock: 1,
+			pinchClose: 1,
+			pinchOpen: 1,
+			shake: 1
+		};
+
+monkey.config.touchProbability = {
+			multipleTaps: 0.05,
+			multipleTouches: 0.05,
+			longPress: 0.05
+		};
+
+monkey.config.frame = {
+			origin: 
+				{ 
+					x: parseInt(UIATarget.localTarget().frontMostApp().rect().origin.x), 
+					y: parseInt(UIATarget.localTarget().frontMostApp().rect().origin.y)+10
+				},
+			size: { 
+					width: parseInt(UIATarget.localTarget().frontMostApp().rect().size.width), 
+					height: parseInt(UIATarget.localTarget().frontMostApp().rect().size.height)-20
+				}
+		};// Ignore the UIAStatusBar area, avoid to drag out the notification page. 
+
+//UI Holes handlers
+var handlers = [];
+handlers.push(new ButtonHandler("WBBack", 10, true));
+handlers.push(new WBScrollViewButtonHandler("weatherLeftBack", 5, false, 1));
+handlers.push(new ButtonHandler("取消", 3, true));
+handlers.push(new ButtonHandler("CloseX", 3, true));
+handlers.push(new ButtonHandler("确定", 3, false));
+
+monkey.config.conditionHandlers = handlers;
+
+//ANR settings
+var aFingerprintFunction = function() {
+    var mainWindow = UIATarget.localTarget().frontMostApp().mainWindow();
+    //if an error occurs log it and make it the fingerprint
+    try {
+        var aString = mainWindow.elementAccessorDump("tree", true);
+        // var aString = mainWindow.logElementTree();
+        // var aString = mainWindow.logElementJSON(["name"])
+        if (monkey.config.anrSettings.debug) {
+            UIALogger.logDebug("fingerprintFunction tree=" + aString);
+        }
+    }
+    catch (e) {
+        aString = "fingerprintFunction error:" + e;
+        UIALogger.logWarning(aString);
+    }
+    return aString;
+};
+monkey.config.anrSettings.fingerprintFunction = false;//false | aFingerprintFunction
+monkey.config.anrSettings.eventsBeforeANRDeclared = 18; //throw exception if the fingerprint hasn't changed within this number of events
+monkey.config.anrSettings.eventsBetweenSnapshots = 8; //how often (in events) to take a snapshot using the fingerprintFunction 
+monkey.config.anrSettings.debug = true;  //log extra info on ANR state changes
+
+// Release the monkey!
+monkey.RELEASE_THE_MONKEY();

data/lib/ui-auto-monkey/handler/buttonHandler.js

@@ -0,0 +1,111 @@
+// Copyright (c) 2015 Yahoo inc. (http://www.yahoo-inc.com)
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+//Conforms to the ConditionHandler protocol in UIAutoMonkey
+//Usage 
+//  var handlers = [ ];
+//  var handlerInterval = 20;  //every how many events to process. Can vary by each handler, but often useful to group them
+//  handlers.push(new ButtonHandler("Done", handlerInterval, false));  //every 20 events, press "Done" button if found as a top level button (no nav bar). 
+//  ...
+//  config.conditionHandlers = handlers
+//  
+function ButtonHandler(buttonName, checkEveryNumber, useNavBar, optionalIsTrueFunction) {
+	this.buttonName = buttonName;
+	this.checkEveryNumber = checkEveryNumber || 10;
+	if (useNavBar == undefined) {
+		useNavBar = true;
+	};
+	this.useNavBar = useNavBar;
+	this.optionalIsTrueFunction = optionalIsTrueFunction || null;
+	//stats
+	this.statsIsTrueInvokedCount = 0;
+	this.statsIsTrueReturnedTrue = 0;
+	this.statsIsTrueReturnedFalse = 0;
+	this.statsHandleInvokedCount = 0;
+	this.statsHandleNotValidAndVisibleCount = 0;
+	this.statsHandleErrorCount = 0;
+}
+
+// return true if we our button is visible 
+ButtonHandler.prototype.isTrue = function(target, eventCount, mainWindow) {
+	this.statsIsTrueInvokedCount++;
+	var result;
+	if (this.optionalIsTrueFunction == null) {
+		var aButton = this.findButton(target);
+        // result = aButton.isNotNil() && aButton.validAndVisible();
+        result = aButton.isNotNil() && aButton.isValid() && aButton.isVisible();
+    } else {
+	    result = this.optionalIsTrueFunction(target, eventCount, mainWindow);
+    }
+    if (result) {
+	  this.statsIsTrueReturnedTrue++;
+    } else {
+	  this.statsIsTrueReturnedFalse++;
+    };
+    return result;
+};
+
+ButtonHandler.prototype.findButton = function(target) {
+	return this.useNavBar ? 
+	    target.frontMostApp().mainWindow().navigationBar().buttons()[this.buttonName] :
+        target.frontMostApp().mainWindow().buttons()[this.buttonName];	
+};
+	
+//every checkEvery() number of events our isTrue() method will be queried.
+ButtonHandler.prototype.checkEvery = function() {
+    return this.checkEveryNumber;
+};
+
+// if true then after we handle an event consider the particular Monkey event handled, and don't process the other condition handlers.
+ButtonHandler.prototype.isExclusive = function() {
+    return true;
+};
+
+// Press our button
+ButtonHandler.prototype.handle = function(target, mainWindow) {
+	this.statsHandleInvokedCount++;
+	var button = this.findButton(target);
+	if (button.isValid() && button.isVisible()) {
+		try{
+		    button.tap();
+		} catch(err) {
+			this.statsHandleErrorCount++;
+			UIALogger.logWarning(err);
+		}
+	} else {
+		this.statsHandleNotValidAndVisibleCount++
+		//UIALogger.logWarning(this.toString() + " button is not validAndVisible");
+	};
+};
+
+ButtonHandler.prototype.toString = function() {
+	return ["MonkeyTest::ButtonHandler(" + this.buttonName, this.checkEveryNumber, this.useNavBar, ")"].join();
+};
+
+ButtonHandler.prototype.logStats = function() {
+	UIALogger.logDebug([this.toString(),
+	    "IsTrueInvokedCount", this.statsIsTrueInvokedCount,
+		"IsTrueReturnedTrue", this.statsIsTrueReturnedTrue,
+		"IsTrueReturnedFalse", this.statsIsTrueReturnedFalse,
+		"HandleInvokedCount", this.statsHandleInvokedCount,
+		"HandleNotValidAndVisibleCount", this.statsHandleNotValidAndVisibleCount,
+		"HandleErrorCount", this.statsHandleErrorCount].join());
+};

data/lib/ui-auto-monkey/handler/wbScrollViewButtonHandler.js

@@ -0,0 +1,114 @@
+// Copyright (c) 2015 Yahoo inc. (http://www.yahoo-inc.com)
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+//Conforms to the ConditionHandler protocol in UIAutoMonkey
+//Usage 
+//  var handlers = [ ];
+//  var handlerInterval = 20;  //every how many events to process. Can vary by each handler, but often useful to group them
+//  handlers.push(new ButtonHandler("Done", handlerInterval, false));  //every 20 events, press "Done" button if found as a top level button (no nav bar). 
+//  ...
+//  config.conditionHandlers = handlers
+//  
+function WBScrollViewButtonHandler(buttonName, checkEveryNumber, useNavBar, scrollViewIndex, optionalIsTrueFunction) {
+	this.buttonName = buttonName;
+	this.scrollViewIndex = scrollViewIndex;
+	this.checkEveryNumber = checkEveryNumber || 10;
+	if (useNavBar == undefined) {
+		useNavBar = true;
+	};
+	this.useNavBar = useNavBar;
+	this.optionalIsTrueFunction = optionalIsTrueFunction || null;
+	//stats
+	this.statsIsTrueInvokedCount = 0;
+	this.statsIsTrueReturnedTrue = 0;
+	this.statsIsTrueReturnedFalse = 0;
+	this.statsHandleInvokedCount = 0;
+	this.statsHandleNotValidAndVisibleCount = 0;
+	this.statsHandleErrorCount = 0;
+}
+
+// return true if we our button is visible 
+WBScrollViewButtonHandler.prototype.isTrue = function(target, eventCount, mainWindow) {
+	this.statsIsTrueInvokedCount++;
+	var result;
+	if (this.optionalIsTrueFunction == null) {
+		var aButton = this.findButton(target);
+        // result = aButton.isNotNil() && aButton.validAndVisible();
+        result = aButton.isNotNil() && aButton.isValid();
+    } else {
+	    result = this.optionalIsTrueFunction(target, eventCount, mainWindow);
+    }
+    if (result) {
+	  this.statsIsTrueReturnedTrue++;
+    } else {
+	  this.statsIsTrueReturnedFalse++;
+    };
+    return result;
+};
+
+WBScrollViewButtonHandler.prototype.findButton = function(target) {
+	return this.useNavBar ? 
+	    target.frontMostApp().mainWindow().navigationBar().buttons()[this.buttonName]:
+        target.frontMostApp().mainWindow().scrollViews()[this.scrollViewIndex].buttons()[this.buttonName];
+};
+	
+//every checkEvery() number of events our isTrue() method will be queried.
+WBScrollViewButtonHandler.prototype.checkEvery = function() {
+    return this.checkEveryNumber;
+};
+
+// if true then after we handle an event consider the particular Monkey event handled, and don't process the other condition handlers.
+WBScrollViewButtonHandler.prototype.isExclusive = function() {
+    return true;
+};
+
+// Press our button
+WBScrollViewButtonHandler.prototype.handle = function(target, mainWindow) {
+	this.statsHandleInvokedCount++;
+	var button = this.findButton(target);
+	if (button.isValid()) {
+		try{
+			var x = button.rect().origin.x;
+			var y = button.rect().origin.y;
+			target.tap({x:x, y:y});
+		} catch(err) {
+			this.statsHandleErrorCount++;
+			UIALogger.logWarning(err);
+		}
+	} else {
+		this.statsHandleNotValidAndVisibleCount++
+		//UIALogger.logWarning(this.toString() + " button is not validAndVisible");
+	};
+};
+
+WBScrollViewButtonHandler.prototype.toString = function() {
+	return ["MonkeyTest::WBScrollViewButtonHandler(" + this.buttonName, this.checkEveryNumber, this.useNavBar, this.scrollViewIndex, ")"].join();
+};
+
+WBScrollViewButtonHandler.prototype.logStats = function() {
+	UIALogger.logDebug([this.toString(),
+	    "IsTrueInvokedCount", this.statsIsTrueInvokedCount,
+		"IsTrueReturnedTrue", this.statsIsTrueReturnedTrue,
+		"IsTrueReturnedFalse", this.statsIsTrueReturnedFalse,
+		"HandleInvokedCount", this.statsHandleInvokedCount,
+		"HandleNotValidAndVisibleCount", this.statsHandleNotValidAndVisibleCount,
+		"HandleErrorCount", this.statsHandleErrorCount].join());
+};

data/lib/ui-auto-monkey/tuneup/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Alex Vollmer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/ui-auto-monkey/tuneup/assertions.js

@@ -0,0 +1,402 @@
+/**
+ * The exception thrown when a 'fail' is used.
+ *
+ * @param message - reason the test failed/aborted
+ */
+function FailureException(message) {
+    this.name = 'FailureException';
+    this.message = message;
+    this.toString = function() {
+        return this.name + ': "' + this.message + '"';
+    };
+}
+
+/**
+ * Just flat-out fail the test with the given message
+ */
+function fail(message) {
+  throw new FailureException(message);
+}
+
+/**
+ * Perform an assertion several times. If the assertion passes before the
+ * maximum number of iterations, the assertion passes. Otherwise the
+ * assertion fails
+ * @param f The function to perform (possibly) multiple times
+ * @param maxTries (optional) The maximum number of attempts
+ * @param delay (optional) The amount of time to pause between attempts
+ */
+function retry() {
+  var f = arguments[0];
+  var maxTries = 3;
+  var delay = 0.5;
+  if (arguments.length > 1) {
+    maxTries = arguments[1];
+  }
+  if (arguments.length > 2) {
+    delay = arguments[2];
+  }
+
+  var tries = 0;
+  var exception = null;
+  while (tries < maxTries) {
+    try {
+      f();
+      return;  // if we get here, our function must have passed (no exceptions)
+    }
+    catch(e) {
+      exception = e;
+      tries++;
+      UIATarget.localTarget().delay(delay);
+    }
+  }
+  throw exception;
+}
+
+/**
+ * The exception thrown for all assert* failures.
+ *
+ * @param message - reason the assertion failed
+ */
+function AssertionException(message) {
+    this.name = 'AssertionException';
+    this.message = message;
+    this.toString = function() {
+        return this.name + ': "' + this.message + '"';
+    };
+}
+
+/**
+ * Asserts that the given expression is true and throws an exception with
+ * a default message, or the optional +message+ parameter
+ */
+function assertTrue(expression, message) {
+  if (! expression) {
+    if (! message) {
+      message = "Assertion failed";
+    }
+    throw new AssertionException(message);
+  }
+}
+
+/**
+ * Asserts that the given regular expression matches the result of the
+ * given message.
+ * @param pattern - the pattern to match
+ * @param expression - the expression to match against
+ * @param message - an optional string message
+ */
+function assertMatch(regExp, expression, message) {
+  var defMessage = "'" + expression + "' does not match '" + regExp + "'";
+  assertTrue(regExp.test(expression), message ? message + ": " + defMessage : defMessage);
+}
+
+/**
+ * Assert that the +received+ object matches the +expected+ object (using
+ * plain ol' ==). If it doesn't, this method throws an exception with either
+ * a default message, or the one given as the last (optional) argument
+ */
+function assertEquals(expected, received, message) {
+  var defMessage = "Expected <" + expected + "> but received <" + received + ">";
+  assertTrue(expected == received, message ? message + ": " + defMessage : defMessage);
+}
+
+/**
+ * Assert that the +received+ object does not matches the +expected+ object (using
+ * plain ol' !=). If it doesn't, this method throws an exception with either
+ * a default message, or the one given as the last (optional) argument
+ */
+function assertNotEquals(expected, received, message) {
+    var defMessage = "Expected not <" + expected + "> but received <" + received + ">";
+    assertTrue(expected != received, message ? message + ": " + defMessage : defMessage);
+}
+
+/**
+ * Asserts that the given expression is false and otherwise throws an
+ * exception with a default message, or the optional +message+ parameter
+ */
+function assertFalse(expression, message) {
+  assertTrue(! expression, message);
+}
+
+/**
+ * Asserts that the given object is null or UIAElementNil (UIAutomation's
+ * version of a null stand-in). If the given object is not one of these,
+ * an exception is thrown with a default message or the given optional
+ * +message+ parameter.
+ */
+function assertNull(thingie, message) {
+  var defMessage = "Expected a null object, but received <" + thingie + ">";
+  // TODO: string-matching on UIAElementNil makes my tummy feel bad. Fix it.
+  assertTrue(thingie === null || thingie.toString() == "[object UIAElementNil]",
+    message ? message + ": " + defMessage : defMessage);
+}
+
+/**
+ * Asserts that the given object is not null or UIAElementNil (UIAutomation's
+ * version of a null stand-in). If it is null, an exception is thrown with
+ * a default message or the given optional +message+ parameter
+ */
+function assertNotNull(thingie, message) {
+  var defMessage = "Expected not null object";
+  assertTrue(thingie !== null && thingie.toString() != "[object UIAElementNil]",
+    message ? message + ": " + defMessage : defMessage);
+}
+
+function OnPassException(message) {
+  this.name = 'OnPassException';
+  this.message = message;
+  this.toString = function() {
+      return this.name + ': "' + this.message + '"';
+  };
+}
+
+function PropertyMismatchException(propName, expected, given) {
+  this.name = 'PropertyMismatchException';
+  this.message = propName + ": expected <" + expected + "> given <" + given + ">";
+  this.toString = function() {
+    return this.name + ": " + this.message;
+  }
+}
+
+/**
+ * Assert that the given definition matches the given element. The
+ * definition is a JavaScript object whose property hierarchy matches
+ * the given UIAElement.  Property names in the given definition that match a
+ * method will cause that method to be invoked and the matching to be performed
+ * and the result. For example, the UITableView exposes all UITableViewCells through
+ * the cells() method. You only need to specify a 'cells' property to
+ * cause the method to be invoked.
+ */
+function assertElementTree(element, definition) {
+  var onPass = null;
+  if (definition.onPass) {
+    onPass = definition.onPass;
+    delete definition.onPass;
+  }
+
+  try {
+    assertPropertiesMatch(definition, element, 0);
+  }
+  catch(e) {
+    fail(e.toString())
+  }
+
+  if (onPass) {
+    try {
+      onPass(element);
+    }
+    catch(e) {
+      throw new OnPassException("Failed to execute 'onPass' callback: " + e);
+    }
+  }
+}
+
+/**
+ * Assert that the given window definition matches the current main window. The
+ * window definition is a JavaScript object whose property hierarchy matches
+ * the main UIAWindow.  Property names in the given definition that match a
+ * method will cause that method to be invoked and the matching to be performed
+ * and the result. For example, the UIAWindow exposes all UITableViews through
+ * the tableViews() method. You only need to specify a 'tableViews' property to
+ * cause the method to be invoked.
+ *
+ * PROPERTY HIERARCHY Property definitions can be nested as deeply as
+ * necessary. Matching is done by traversing the same path in the main
+ * UIAWindow as your screen definition. For example, to make assertions about
+ * the left and right buttons in a UINavigationBar you can do this:
+ *
+ * assertWindow({
+ *   navigationBar: {
+ *     leftButton: { name: "Back" },
+ *     rightButton: ( name: "Done" },
+ *   }
+ * });
+ *
+ * PROPERTY MATCHERS For each property you wish to make an assertion about, you
+ * can specify a string, number regular expression or function. Strings and
+ * numbers are matches using the assertEquals() method. Regular expressions are
+ * matches using the assertMatch() method.
+ *
+ * If you specify 'null' for a property, it means you don't care to match.
+ * Typically this is done inside of arrays where you need to match the number
+ * of elements, but don't necessarily care to make assertions about each one.
+ *
+ * Functions are given the matching property as the single argument. For
+ * example:
+ *
+ * assertWindow({
+ *   navigationBar: {
+ *     leftButton: function(button) {
+ *       // make custom assertions here
+ *     }
+ *   }
+ * });
+ *
+ * ARRAYS
+ * If a property you want to match is an array (e.g. tableViews()), you can
+ * specify one of the above matchers for each element of the array. If the
+ * number of provided matchers does not match the number of given elements, the
+ * assertion will fail (throw an exception)
+ *
+ * In any case, you specify another object definition for each property to
+ * drill-down into the atomic properties you wish to test. For example:
+ *
+ * assertWindow({
+ *   navigationBar: {
+ *     leftButton: { name: "Back" },
+ *     rightButton: ( name: "Done" },
+ *   },
+ *   tableViews: [
+ *     {
+ *       groups: [
+ *         { name: "First Group" },
+ *         { name: "Second Group" }
+ *       ],
+ *       cells: [
+ *         { name: "Cell 1" },
+ *         { name: "Cell 2" },
+ *         { name: "Cell 3" },
+ *         { name: "Cell 4" }
+ *       ]
+ *     }
+ *   ]
+ * });
+ *
+ * HANDLING FAILURE If any match fails, an appropriate exception will be
+ * thrown. If you are using the test structure provided by tuneup, this will be
+ * caught and detailed correctly in Instruments.
+ *
+ * POST-PROCESSING If your screen definition provides an 'onPass' property that
+ * points to a function, that function will be invoked after all matching has
+ * been peformed on the current window and all assertions have passed. This
+ * means you can assert the structure of your screen and operate on it in one
+ * pass:
+ *
+ * assertWindow({
+ *   navigationBar: {
+ *     leftButton: { name: "Back" }
+ *   },
+ *   onPass: function(window) {
+ *     var leftButton = window.navigationBar().leftButton();
+ *     leftButton.tap();
+ *   }
+ * });
+ */
+function assertWindow(window) {
+  target = UIATarget.localTarget();
+  application = target.frontMostApp();
+  mainWindow = application.mainWindow();
+
+  assertElementTree(mainWindow, window);
+}
+
+/**
+ * Asserts that the +expected+ object matches the +given+ object by making
+ * assertions appropriate based on the type of each property in the
+ * +expected+ object. This method will recurse through the structure,
+ * applying assertions for each matching property path. See the description
+ * for +assertWindow+ for details on the matchers.
+ */
+function assertPropertiesMatch(expected, given, level) {
+  for (var propName in expected) {
+    if (expected.hasOwnProperty(propName)) {
+      var expectedProp = expected[propName];
+
+      if (propName.match(/~iphone$/)) {
+        if (UIATarget.localTarget().model().match(/^iPad/) !== null ||
+            UIATarget.localTarget().name().match(/^iPad Simulator$/) !== null) {
+          continue;  // we're on the wrong platform, ignore
+        }
+        else {
+          propName = propName.match(/^(.*)~iphone/)[1];
+        }
+      }
+      else if (propName.match(/~ipad$/)) {
+        if (UIATarget.localTarget().model().match(/^iPad/) === null &&
+            UIATarget.localTarget().name().match(/^iPad Simulator/) === null) {
+          continue;  // we're on the wrong platform, ignore
+        }
+        else {
+          propName = propName.match(/^(.*)~ipad/)[1];
+        }
+      }
+
+      var givenProp = given[propName];
+
+      if (typeof(givenProp) == "function") {
+        try {
+          // We have to use eval (shudder) because calling functions on
+          // UIAutomation objects with () operator crashes
+          // See Radar bug 8496138
+          givenProp = eval("given." + propName + "()");
+        }
+        catch (e) {
+          UIALogger.logError("[" + propName + "]: Unable to evaluate against " + given);
+          continue;
+        }
+      }
+
+      if (givenProp === null) {
+        throw new AssertionException("Could not find given " + given + " property named: " + propName);
+      }
+      else {
+        var objType = Object.prototype.toString.call(givenProp);
+        if (objType == "[object UIAElementNil]") {
+          throw new AssertionException("found no elements for " + given.toString() + '.' + propName + "()");
+        }
+        else if (objType == "[object Undefined]") {
+          throw new AssertionException(given.toString() + '.' + propName + "() method not found.");
+        }
+      }
+
+      // null indicates we don't care to match
+      if (expectedProp === null) {
+        continue;
+      }
+
+      var expectedPropType = typeof(expectedProp);
+      if (expectedPropType == "string") {
+        assertEquals(expectedProp, givenProp);
+      }
+      else if (expectedPropType == "number") {
+        assertEquals(expectedProp, givenProp);
+      }
+      else if (expectedPropType == "boolean") {
+        assertEquals(expectedProp, givenProp);
+      }
+      else if (expectedPropType == "function") {
+        if (expectedProp.constructor == RegExp) {
+          assertMatch(expectedProp, givenProp);
+        }
+        else {
+          expectedProp(givenProp);
+        }
+      }
+      else if (expectedPropType == "object") {
+        if (expectedProp.constructor === Array) {
+          assertEquals(expectedProp.length, givenProp.length, "Length of " + propName + " does not match");
+          for (var i = 0; i < expectedProp.length; i++) {
+            var exp = expectedProp[i];
+            var giv = givenProp[i];
+            assertPropertiesMatch(exp, giv, level + 1);
+          }
+        }
+        else if (expectedProp.constructor === RegExp) {
+          assertMatch(expectedProp, givenProp);
+        }
+        else if (typeof(givenProp) == "object") {
+          assertPropertiesMatch(expectedProp, givenProp, level + 1);
+        }
+        else {
+          var message = "[" + propName + "]: Unknown type of object constructor: " + expectedProp.constructor;
+          UIALogger.logError(message);
+          throw new AssertionException(message);
+        }
+      }
+      else {
+        UIALogger.logError("[" + propName + "]: unknown type for expectedProp: " + typeof(expectedProp));
+      }
+    }
+  }
+}