小编mon*_*962的帖子

我必须测试一个消息路由应用程序,其功能大致如下: - 消息被发送到app - app检查消息 - 消息根据消息内容转发到某处

绝大多数测试用例几乎相同; 生成特定类型的消息,将其加载到系统中,等待几秒钟,然后检查所需的目标以确保消息正确转发.

而不是在Cucumber中生成100个几乎相同的测试用例,是否有建议的方法来生成一个测试用例,并让它重复循环遍历所有(message,required_destination)元组？我更喜欢将这些元组保存到YAML文件而不是数据库中,以便于维护,但任何一种解决方案都可以.

Clojure中简单的新手问题......

如果我在Clojure向量中有奇数个元素,我该如何提取"中间"值？我已经看了一段时间,但无法解决这个问题!

一些例子:

• (middle-value [0]) 应该回来 [0]
• (middle-value [0 1 2]) 应该回来 [1]
• (middle-value [0 1 :abc 3 4]) 应该回来 [:abc]
• (middle-value [0 1 2 "test" 4 5 6]) 应该回来 ["test"]

我有一系列Clojure地图,看起来像这样:

({:date "2000-01-01" :value 123} 
 {:date "2000-01-02" :value 487} 
 ... 
 {:date "2014-05-01" :value 17})

我想构建一个函数,它将返回一个类似结构的映射序列,但只包含那些映射:例如"2005-11-14"和"2007-08-03"之间的日期值.

在他们目前的YYYY-MM-DD形式中,日期是可比较的,因此(compare "2000-01-02" "2001-03-04")按预期工作.但是,我无法弄清楚如何从序列中提取:date值并进行比较.

我已经做到了,(filter #(> 0 (compare (:date %)) "2099-12-09") data)但无法进一步.救命!

我正在从事个人市场分析项目.我有一个数据结构代表了市场上所有最近的转折点,看起来像这样:

[{:high 1.121455, :time "2016-08-03T05:15:00.000000Z"}
 {:low 1.12109, :time "2016-08-03T05:15:00.000000Z"}
 {:high 1.12173, :time "2016-08-03T04:30:00.000000Z"}
 {:high 1.121925, :time "2016-08-03T00:00:00.000000Z"}
 {:high 1.12215, :time "2016-08-02T23:00:00.000000Z"}
 {:high 1.12273, :time "2016-08-02T21:15:00.000000Z"}
 {:high 1.12338, :time "2016-08-02T18:15:00.000000Z"}
 {:low 1.119215, :time "2016-08-02T12:30:00.000000Z"}
 {:low 1.118755, :time "2016-08-02T12:00:00.000000Z"}
 {:low 1.117575, :time "2016-08-02T06:00:00.000000Z"}
 {:low 1.117135, :time "2016-08-02T04:30:00.000000Z"}
 {:low 1.11624, :time "2016-08-02T02:00:00.000000Z"}
 {:low 1.115895, :time "2016-08-01T21:30:00.000000Z"}
 {:low 1.11552, :time "2016-08-01T11:45:00.000000Z"}
 {:low 1.11049, :time "2016-07-29T12:15:00.000000Z"}
 {:low 1.108825, :time "2016-07-29T08:30:00.000000Z"}
 {:low 1.10839, :time "2016-07-29T08:00:00.000000Z"}
 {:low 1.10744, :time "2016-07-29T05:45:00.000000Z"}
 {:low 1.10716, :time "2016-07-28T19:30:00.000000Z"}
 {:low 1.10705, :time …

为了测试一些安全软件,我需要能够在Windows中创建一个大的(可配置的)新进程(不是线程!),非常快,让它们存在一段(可配置的)时间,然后干净地终止.这些过程根本不应该做任何事情 - 只存在指定的持续时间.

最终,我希望能够运行如下:

C:\> python process_generate.py --processes=150 --duration=2500

它可以非常快速地创建150个新进程,使它们在2500毫秒内保持活动状态,然后让它们尽快终止.

作为一个起点,我跑了

from multiprocessing import Process
import os

def f():
    pass

if __name__ == '__main__':
    import datetime
    count = 0
    startime = datetime.datetime.now()
    while True:
        p = Process(target=f)
        p.start()
        p.terminate()
        count += 1
        if count % 1000 == 0:
            now = datetime.datetime.now()
            print "Started & stopped d processes in %s seconds" % (count, str(now-starttime))

并且发现我可以在笔记本电脑上连续创建和终止大约70个进程/秒,创建的进程直接终止.约70个过程/秒速率持续约一小时的持续时间.

当我将代码更改为

from multiprocessing import Process
import os
import time

def f_sleep():
    time.sleep(1)

if __name__ …

我在R中有一个数据框,如下所示:

> TimeOffset, Source, Length 
> 0         1           1500
> 0.1       1           1000    
> 0.2       1           50
> 0.4       2           25
> 0.6       2           3
> 1.1       1           1500
> 1.4       1           18
> 1.6       2           2500
> 1.9       2           18
> 2.1       1           37
> ...

我想把它转换成

> TimeOffset, Source, Length
> 0.2         1       2550
> 0.6         2       28
> 1.4         1       1518
> 1.9         2       2518
> ...

试着把它放到英文中,我想把连续的记录分成相同的'Source',然后打印出每组的一条记录,显示该组中的最高时间偏移,来源和该组中长度的总和.

TimeOffset值将始终增加.

我怀疑这在R中是可能的,但我真的不知道从哪里开始.在紧要关头,我可以导出数据帧,并在例如Python中进行,但如果可能的话,我宁愿留在R中.

提前感谢您提供的任何帮助

(我今天早些时候试着提出这个问题,但后来发现我过分简化了问题;我收到的答案是正确的,但由于我在原问题中对问题的过度简化,我无法使用它们.这是我的第二次尝试...)

我在R中有一个数据框,如下所示:

"Timestamp", "Source", "Target", "Length", "Content"
0.1        , P1      , P2      , 5       , "ABCDE"
0.2        , P1      , P2      , 3       , "HIJ"
0.4        , P1      , P2      , 4       , "PQRS"
0.5        , P2      , P1      , 2       , "ZY"
0.9        , P2      , P1      , 4       , "SRQP"
1.1        , P1      , P2      , 1       , "B"
1.6        , P1      , P2      , 3       , "DEF"
2.0        , P2      , P1      , 3       , "IJK"
... …