嵌入式自动化测试-遇到问题，解决问题

此文阅次

睡眠,停顿 [等待页面元素加载完成]

1
2
3
4
5
6
7
8
9
function sleep(delay)
{
    var start = new Date().getTime();
    while (new Date().getTime() < start + delay);
}
 
//usage
//wait for 3 seconds
sleep(3000);

webdriver 的三种等待方式 - 风雨的日志 - 网易博客
http://blog.163.com/yang_jianli/blog/static/16199000620157445841592/

Appium 三种wait方法（appium 学习之改造轮子） - to be crazy - 博客园
http://www.cnblogs.com/tobecrazy/p/4596214.html

selenium webdriver（Appium）如何等待页面元素加载完成 - 北极的冰箱 - 博客频道 - CSDN.NET
http://blog.csdn.net/jlminghui/article/details/41821533

js执行过程中,页面并不同步。 聪明的浏览器

1
2
3
4
5
因为渲染树的改变导致的重绘或重排操作都可能代价很高，浏览器会对这个改动做很多优化。
一个策略就是不要立即做操作，而是批量进行。比如把你的脚本对DOM的修改放入一个队列，在队列所有操作结束后只需要进行一次绘制即可。


浏览器引擎可能会针对重排做了优化。比如Opera，它会等到有足够数量的变化发生，或者等到一定的时间，或者等一个线程结束，再一起处理，这样就只发生一次重排。但除了渲染树的直接变化，当获取一些属性时，浏览器为取得正确的值也会触发重排。这样就使得浏览器的优化失效了。这些属性包括：offsetTop、offsetLeft、 offsetWidth、offsetHeight、scrollTop、scrollLeft、scrollWidth、scrollHeight、clientTop、clientLeft、clientWidth、clientHeight、getComputedStyle() (currentStyle in IE)。所以，在多次使用这些值时应进行缓存。

  • 解决办法：方法延迟执行

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    function repeat(func, times, wait) {
        return function (str) {
          for (var i = 0; i < times; i++) {
            setTimeout(function () {
              func(str);
            }, 5000 * i);
          }
        }
      }
     
      var repeatedFun = repeat(alert, 2, 5000);
      repeatedFun("hellworld");//会alert十次 helloworld, 每次间隔5秒

  • 优化， 使用 setInterval,减少循环控制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    function repeat(func, times, wait) {
        return function (str) {
          var handle_num = 0,
            handle =
              setInterval(function () {
                func(str);
     
                if (++handle_num >= times) {
                  clearInterval(handle);
                  return;
                }
              }, wait);
        }
      }
     
      var repeatedFun = repeat(alert, 2, 5000);
      repeatedFun("hellworld");//会alert十次 helloworld, 每次间隔5秒

  • 证实:线程执行完之前浏览器不会刷新ui,需要借助异步线程来完成

    1
    2
    3
    4
    5
    6
    7
    8
    el('.nav-bar-title.ng-binding').triggerHandler('click');
    el('.bookname_content>.bookname', 1).triggerHandler('click');


    setTimeout(function () {
      el('.nav-bar-title.ng-binding').triggerHandler('click');
      el('.bookname_content>.bookname', 2).triggerHandler('click');
    }, 0);// 上一步页面更新

  • 循环控制异步调用(存在问题:循环间不能等差时间调用,后文使用递归解决)

    1
    2
    3
    4
    5
    6
    7
    8
    for (var i = 0; i < $('.bookname_content>.bookname').length; i++) {
      console.log('>', i);
      setTimeout(function (i) {
        console.log("ddd", i);
        el('.nav-bar-title.ng-binding').triggerHandler('click');
        el('.bookname_content>.bookname', i).triggerHandler('click');
      }, 1000 * i)
    }
  • 批量异步方法执行 + 异步函数执行asyn(含 柯里化 ) + _forEach递归
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
 * 异步执行函数,目的:页面同步刷新
 * @param func
 * @param time
 * @returns {Function}
 */
function asyn(func, time = 1000) {
  return function (prom) {
    setTimeout(function () {
      func(prom)
    }, time)
  }
}


function _forEach(start, end) {
  asyn(function (prom) {
    // console.log('dd', prom);
    el('.nav-bar-title.ng-binding').triggerHandler('click');
    asyn(function (prom) {
      // console.log('dd2', prom);
      el('.bookname_content>.bookname', prom).triggerHandler('click');
       ++index < length && _Each(index, length);// 递归调用自己,相比for没有了时间计算
    })(prom);
  })(start);
}


_forEach(0, 2);// 启动
  • 批量异步方法执行 + 异步函数执行asyn(含 柯里化 ) + _forEach递归 + _forEach 柯里化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
currying(function _Each(start, end) {
  asyn(function (prom) {
    el('.nav-bar-title.ng-binding').triggerHandler('click');


    asyn(function (prom) {
      el('.bookname_content>.bookname', prom).triggerHandler('click');
      //noinspection JSAnnotator
      ++start <= end && _Each(start, end);// 递归调用自己,相比for没有了时间计算
    })(prom);
  })(start);
})(0, 2);


/**
 * 柯里化
 * @param func
 * @returns {Function}
 * @private
 */
function currying(func) {
  var _arguments = arguments;
  return function () {
    return func.call(this, ...arguments, ..._arguments);
  }
}


/**
 * 异步执行函数,目的:页面同步刷新(柯里化)
 * @param func
 * @param time
 * @returns {Function}
 */
function asyn(func, time = 1000) {
  return function () {
    var _arguments = arguments;
    setTimeout(function () {
      return func.call(this, ..._arguments);
    }, time)
  }
}

  • 批量异步方法执行-方法数组封装(失败:无法连续执行)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    currying(function _Each(start, end) {
      var func1 = [function () {
        el('.nav-bar-title.ng-binding').triggerHandler('click')
      }];
      var func2 = [function (prom) {
        el('.bookname_content>.bookname', prom).triggerHandler('click')
      }, start];


      bachSycFunc(func1, func2);
      ++start <= end && _Each(start, end);// 递归调用自己,相比for没有了时间计算
      // 问题关键:循环间不能连续
    })(0, 2);


    /**
     * 批量异步方法执行
     * @param funcs
     */
    function bachSycFunc(...funcs) {
      currying(function _Each(_funcs, index) {
        asyn(function (_funcs, index) {
          _funcs[index][0](_funcs[index][1]);
          ++index < _funcs.length && _Each(_funcs, index)
        })(_funcs, index);
      })(funcs, 0)
    }

  • 批量异步方法执行 + 异步函数执行asyn(含 柯里化 ) + _forEach递归

    • _forEach 柯里化 + 返回Promise 处理连续的func调用 ★ (特技加满,完整版)
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      // 调用示例
      currying(function _Each(index, length) {
        
        sycFuncPromise(function () {
          el('.nav-bar-title.ng-binding').triggerHandler('click');
        })()
          .then(function () {
            return sycFuncPromise(function () {
              el('.bookname_content>.bookname', index).triggerHandler('click');
              ++index < length && _Each(index, length);// 递归调用自己,相比for没有了时间计算
            })()
          })
          .then(function () {
            // ...
          })
        
      })(0, $('.bookname_content>.bookname').length);


      / ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** * * ** ** ** ** ** ** ** **/



      /**
       * 返回Promise的方法,处理连续的func调用
       * @param func
       * @returns {Function}
       */
      function sycFuncPromise(func) {
        return function () {
          var _arguments = arguments;
          return new Promise(function (resolve, reject) { // promise方式
            asyn(function () {
              func(_arguments);
              resolve();
            })();
          })
        }
      }


      /**
       * 柯里化
       * @param func
       * @returns {Function}
       * @private
       */
      function currying(func) {
        var _arguments = arguments;
        return function () {
          return func.call(this, ...arguments, ..._arguments);
        }
      }


      /**
       * 异步执行函数,目的:页面同步刷新(柯里化)
       * @param func
       * @param time
       * @returns {Function}
       */
      function asyn(func, time = 1000) {
        return function () {
          var _arguments = arguments;
          setTimeout(function () {
            return func.call(this, ..._arguments);
          }, time)
        }
      }
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码