扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >【测试】python 模拟snmp-se
  • 958

0
分享到

【测试】python 模拟snmp-se

测试pythonse 2023-01-31 02:01:13 958人浏览 八月长安

Python 官方文档：入门教程 => 点击学习

摘要

如下脚本，模拟windows和linux上的snmp-agent，返回数据给snmp请求者。直接上代码吧：# -*- coding: utf-8 -*- import binascii, struct import Socket impor

如下脚本，模拟windows和linux上的snmp-agent，返回数据给snmp请求者。

直接上代码吧：

# -*- coding: utf-8 -*-
import binascii, struct
import Socket
import time
from threading import Thread

'''
windows OID
1.3.6.1.2.1.25.2.3.1.6.1 [ObjectIdentifier] //硬盘 
1.3.6.1.2.1.25.2.3.1.6.2 [ObjectIdentifier] //硬盘 
1.3.6.1.2.1.25.2.3.1.6.3 [ObjectIdentifier] //硬盘 
1.3.6.1.2.1.25.2.3.1.6.4 [ObjectIdentifier] //硬盘 
1.3.6.1.2.1.25.2.3.1.6.5 [ObjectIdentifier] //光盘 
1.3.6.1.2.1.25.2.3.1.6.6 [ObjectIdentifier] //光盘 
1.3.6.1.2.1.25.2.3.1.6.7 [ObjectIdentifier] //虚拟内存 
1.3.6.1.2.1.25.2.3.1.6.8 [ObjectIdentifier] //物理内存
OID号不固定，当只有一块硬盘，一个光驱时，物理内存占用OID为1.2.5（2.1占用一般0，不是真实硬盘，不知道是什么意思，真正硬盘占用从2.2开始）
'''

#a 是一个真实的请求内容，def test_parse（）函数可以将他解析出来,并打印出密码，请求类型，请求ID，OID对象
a = '''0x30, 0x82, 0x01, 0x09, 0x02, 0x01, 0x01, 0x04, 
0x06, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0xa0, 
0x81, 0xfb, 0x02, 0x04, 0x4a, 0xbb, 0x2b, 0xac, 
0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x30, 0x81, 
0xec, 0x30, 0x0d, 0x06, 0x09, 0x2b, 0x06, 0x01, 
0x02, 0x01, 0x19, 0x02, 0x02, 0x00, 0x05, 0x00, 
0x30, 0x0f, 0x06, 0x0b, 0x2b, 0x06, 0x01, 0x02, 
0x01, 0x19, 0x03, 0x03, 0x01, 0x02, 0x01, 0x05, 
0x00, 0x30, 0x0f, 0x06, 0x0b, 0x2b, 0x06, 0x01, 
0x02, 0x01, 0x19, 0x02, 0x03, 0x01, 0x05, 0x01, 
0x05, 0x00, 0x30, 0x0f, 0x06, 0x0b, 0x2b, 0x06, 
0x01, 0x02, 0x01, 0x19, 0x02, 0x03, 0x01, 0x05, 
0x02, 0x05, 0x00, 0x30, 0x0f, 0x06, 0x0b, 0x2b, 
0x06, 0x01, 0x02, 0x01, 0x19, 0x02, 0x03, 0x01, 
0x05, 0x03, 0x05, 0x00, 0x30, 0x0f, 0x06, 0x0b, 
0x2b, 0x06, 0x01, 0x02, 0x01, 0x19, 0x02, 0x03, 
0x01, 0x05, 0x04, 0x05, 0x00, 0x30, 0x0f, 0x06, 
0x0b, 0x2b, 0x06, 0x01, 0x02, 0x01, 0x19, 0x02, 
0x03, 0x01, 0x06, 0x01, 0x05, 0x00, 0x30, 0x0f, 
0x06, 0x0b, 0x2b, 0x06, 0x01, 0x02, 0x01, 0x19, 
0x02, 0x03, 0x01, 0x06, 0x02, 0x05, 0x00, 0x30, 
0x0f, 0x06, 0x0b, 0x2b, 0x06, 0x01, 0x02, 0x01, 
0x19, 0x02, 0x03, 0x01, 0x06, 0x03, 0x05, 0x00, 
0x30, 0x0f, 0x06, 0x0b, 0x2b, 0x06, 0x01, 0x02, 
0x01, 0x19, 0x02, 0x03, 0x01, 0x06, 0x04, 0x05, 
0x00, 0x30, 0x0f, 0x06, 0x0b, 0x2b, 0x06, 0x01, 
0x02, 0x01, 0x19, 0x02, 0x03, 0x01, 0x06, 0x05, 
0x05, 0x00, 0x30, 0x0f, 0x06, 0x0b, 0x2b, 0x06, 
0x01, 0x02, 0x01, 0x19, 0x02, 0x03, 0x01, 0x06, 
0x06, 0x05, 0x00, 0x30, 0x0f, 0x06, 0x0b, 0x2b, 
0x06, 0x01, 0x02, 0x01, 0x19, 0x02, 0x03, 0x01, 
0x06, 0x07, 0x05, 0x00, 0x30, 0x0f, 0x06, 0x0b, 
0x2b, 0x06, 0x01, 0x02, 0x01, 0x19, 0x02, 0x03, 
0x01, 0x06, 0x08, 0x05, 0x00'''

class snmpReqParse:
    struct_type = {0x02:'INTEGER_TYPE',
                   0x30:'SQUENCE_TYPE',
                   0x04:'OCTET_TYPE',
                   0X05:'NULL_TYPE', 
                   0x06:'OBJID_TYPE', 
                   0xa0:'GET_REQ_TYPE', 
                   0xa5:'GET_BULKREQ_TYPE', 
                   0Xa2:'RESPONSE_TYPE'}
    def __init__(self, request):
        self.request = request
        self.objidList = []
        self.requestID = None
        self.getReQtype = 0xa0
        self.publicPasswd = ''
        self.parse()
    def parse(self):
        currentPos = self.parse_header1()
        if not currentPos:
            print "parse SNMP header failed!"
            return
        currentPos = self.parse_header2(currentPos)
        if not currentPos:
            print "parse SNMP header failed!"
            return
        self.parse_obj(currentPos)    
    def parse_obj(self, pos):
        #开始解析obj对象了    
        currentPos = pos
        stype = struct.unpack('B', self.request[currentPos:currentPos+1])[0]
        currentPos += 1
        currentPos = self.struct_parse(currentPos)[0] 
        while len(self.request[currentPos:]) != 0:
            stype = struct.unpack('B', self.request[currentPos:currentPos+1])[0]
            currentPos += 1
            currentPos = self.struct_parse(currentPos)[0]
            stype = struct.unpack('B', self.request[currentPos:currentPos+1])[0]
            if stype != 0x06:
                print "wrong type coding, must be 0x06"
                break
            currentPos += 1
            currentPos, stringLen = self.struct_parse(currentPos)
            objid = struct.unpack(stringLen*'B', self.request[currentPos:currentPos+stringLen])
            objid1stStr = str(divmod(objid[0], 40)[0]) + '.' + str(divmod(objid[0], 40)[1])
            #当obj中每一段中有值大于127时，则后面一个数应该和前面一个数拼起来，例如0x8F和0X65，应该是0x8F*128+65
            templist = []
            temp1 = 0
            for i in objid[1:]:
                if not temp1:
                    if i<=127:
                        templist.append(str(i))
                    else:
                        temp1 = i
                else:
                    templist.append(str((temp1-128)*128+i))
                    temp1 = 0
            objidStr = objid1stStr + '.' + '.'.join(templist)
            self.objidList.append(objidStr)
            currentPos = currentPos+stringLen
            #跳过null type
            currentPos += 2
        #print self.objidList   
    def parse_header2(self, pos):
        #从团体属性密钥结束后，解析到OBject开始
        currentPos = pos
        stype = struct.unpack('B', self.request[currentPos:currentPos+1])[0]
        self.getReqType = stype
        currentPos += 1
        currentPos = self.struct_parse(currentPos)[0]
        stype = struct.unpack('B', self.request[currentPos:currentPos+1])[0]    
        if stype == 0x02:
            startPos = currentPos + 1
            currentPos, stringLen = self.struct_parse(startPos)
            self.requestID = self.request[currentPos:currentPos+stringLen]
            currentPos += stringLen
            #直接跳过error-statues和error-index
            currentPos += 6
            return currentPos
        else:
            print 'wrong type coding ,should be 0x02!'
            return
    def parse_header1(self):
        #start parse，从开始到得到团体属性密钥
        #currentPos为读取数据流的位置
        stype = struct.unpack('B', self.request[0:1])[0]
        if stype == 0x30:
            currentPos = self.struct_parse(1)[0]
            stype = struct.unpack('B', self.request[currentPos:currentPos+1])[0]
            if stype == 0x02:
                startPos = currentPos+1
                currentPos = self.struct_parse(startPos)[0]
                if currentPos - startPos == 1:
                    #不做判断了，直接跳到解析团体关键字
                    startPos = currentPos + 2
                    currentPos, stringLen = self.struct_parse(startPos)
                    self.publicPasswd = self.request[startPos+1:startPos+stringLen+1]
                    currentPos = startPos+stringLen+1 
                    return currentPos
                else:
                    print "wrong SNMP version ，must be v2c!"
            else:
                print "wrong type coding: %s,should be 0x02"%stype
        else:
            print "wrong type coding: %s, should be 0x30 "%stype
    def struct_parse(self, startpos):
        #结构解析，startpos的位置已经是长度字段了，解析出来，最后返回这个结构结尾的pos
        length = struct.unpack('B', self.request[startpos:startpos+1])[0]
        if length == 0x81:
            endpos = startpos + 2
            slen = struct.unpack('B', self.request[startpos+1:endpos])[0]
        elif length == 0x82:
            endpos = startpos + 3
            slen = struct.unpack('!H', self.request[startpos+1:endpos])[0]
        elif length <= 127:
            endpos = startpos + 1
            slen = length
        else:
            print "wrong length coding: "%length
            return
        if len(self.request[endpos:]) < slen:
            print "string is not enough long!"
            return
        return endpos, slen

class snmpResponse:
    OID = {'windows':['1.3.6.1.2.1.25.2.2.0',  #内存总大小(mem_count)，integar类型
                  '1.3.6.1.2.1.25.3.3.1.2.1',  #CPU,integar类型
                  '1.3.6.1.2.1.25.2.3.1.5.1',  #值为0，integar类型
                  '1.3.6.1.2.1.25.2.3.1.5.2',  #硬盘总大小，*4096单位为字节数，integar类型
                  '1.3.6.1.2.1.25.2.3.1.5.3',  #光驱总大小，实际为光盘容量，没有光盘时为0，integar类型
                  '1.3.6.1.2.1.25.2.3.1.5.4',  #暂时不清楚是什么，默认我给它赋值0x009a5f，integar类型
                  '1.3.6.1.2.1.25.2.3.1.6.1',  #值为0，integar类型
                  '1.3.6.1.2.1.25.2.3.1.6.2',  #硬盘占用的大小，integar类型
                  '1.3.6.1.2.1.25.2.3.1.6.3',  #光驱大小，和5.3一致
                  '1.3.6.1.2.1.25.2.3.1.6.4',  #虚拟内存大小，一般不关注，integar类型
                  '1.3.6.1.2.1.25.2.3.1.6.5'], #物理内存使用大小（mem_use），integar类型
       #内存使用率计算方法：(mem_use*65535)/（mem_count*1024）
       'linux':['1.3.6.1.4.1.2021.11.11.0',  #CPU剩余，如40
                '1.3.6.1.4.1.2021.4.5.0',  #内存总大小，integar类型
                '1.3.6.1.4.1.2021.4.6.0',  #内存剩余大小，integar类型
                '1.3.6.1.4.1.2021.9.1.9.1']} #硬盘使用百分比，如60, integar类型
    def __init__(self):
        self.getReqType = 0x00
        self.reqPublicPasswd = ''
        self.reqObjList = []
        self.OIDdic = {}
        self.getResType = 0xa2
        self.respondID = 0
        self.error_index = 0
        self.error_status = 0
        self.simDev = { 'publicPasswd':'public', 
                        'platfORM':'windows', 'CPULOAD':45,
                        'totalMem':1024000, 'usedMem':102400,  #mem单位为kB
                        'totalDisk':512000000, 'usedDisk':100000000}
    def check_request(self):
        if self.getReqType != 0xa0:
            print "this tool can only support get-request"
            return
        if self.reqObjList:
            if self.reqObjList[0] in self.OID['windows']:
                self.simDev['platform'] = 'windows'
                for i in range(0, len(self.reqObjList)):
                    if self.reqObjList[i] not in self.OID['windows']:
                        self.error_index = i + 1
                        self.error_status = 0x02
                        return
                useMemVal = (self.simDev['usedMem']*1024)/65535  
                self.OIDdic = {'1.3.6.1.2.1.25.2.2.0':self.simDev['totalMem'], #内存总大小(mem_count)，integar类型
                               '1.3.6.1.2.1.25.3.3.1.2.1':self.simDev['CPULOAD'],  #CPU,integar类型
                              '1.3.6.1.2.1.25.2.3.1.5.1':0,  #值为0，integar类型
                              '1.3.6.1.2.1.25.2.3.1.5.2':self.simDev['totalDisk']/2048,  #硬盘总大小，*4096单位为字节数，integar类型
                              '1.3.6.1.2.1.25.2.3.1.5.3':0,  #光驱总大小，实际为光盘容量，没有光盘时为0，integar类型
                              '1.3.6.1.2.1.25.2.3.1.5.4':39519,  #暂时不清楚是什么，默认我给它赋值0x009a5f，integar类型
                              '1.3.6.1.2.1.25.2.3.1.6.1':0,  #值为0，integar类型
                              '1.3.6.1.2.1.25.2.3.1.6.2':self.simDev['usedDisk']/2048,  #硬盘占用的大小，integar类型
                              '1.3.6.1.2.1.25.2.3.1.6.3':0,  #光驱大小，和5.3一致
                              '1.3.6.1.2.1.25.2.3.1.6.4':10835,  #虚拟内存大小，一般不关注，integar类型
                              '1.3.6.1.2.1.25.2.3.1.6.5':useMemVal}
            elif self.reqObjList[0] in self.OID['linux']:
                self.simDev['platform'] = 'linux'
                for i in self.reqObjList:
                    if i not in self.OID['linux']:
                        print 'can not support the OID:', i
                        return
                freeCPU = 100 - self.simDev['CPULOAD']
                usedDisk = (self.simDev['usedDisk']*100)/self.simDev['totalDisk']
                freeMemVal = self.simDev['totalMem'] - self.simDev['usedMem']
                self.OIDdic = {'1.3.6.1.4.1.2021.11.11.0':freeCPU,  #CPU剩余
                               '1.3.6.1.4.1.2021.4.5.0':self.simDev['totalMem'],  #内存总大小，integar类型
                               '1.3.6.1.4.1.2021.4.6.0':freeMemVal,  #内存剩余大小，integar类型
                               '1.3.6.1.4.1.2021.9.1.9.1':usedDisk}   #硬盘使用百分比，如60, integar类型
            else:
                print "the objlist will not be supported!"
                return
        else:
            print "error: objlist is Null!" 
            return
    def build_objbuff(self):
        objbuff = ''    
        if self.error_index:
                for i in self.reqObjList:
                    objbuff += self.coding_obj_and_value(i)
        else:
            for i in self.reqObjList:
                objbuff += self.coding_obj_and_value(i, self.OIDdic[i])
        if not objbuff:
            return
        objbuff = '\x30' + self.coding_of_length(len(objbuff)) + objbuff
        return objbuff        
    def build_snmpbuff(self):
        self.check_request()
        objBuff = self.build_objbuff()
        if not objBuff:
            return
        snmpbuff = ''
        if self.simDev['publicPasswd'] != self.reqPublicPasswd:
            print "public keyWord is wrong!"
            return
        else:
            snmpbuff = '\x02' + struct.pack('B', len(self.respondID)) + self.respondID \
                       + '\x02\x01' + struct.pack('B', self.error_status) \
                       + '\x02\x01' + struct.pack('B', self.error_index)
            snmpbuff += objBuff
            snmpbuff = '\xa2' + self.coding_of_length(len(snmpbuff)) + snmpbuff
            snmpbuff = '\x02\x01\x01\x04' + struct.pack('B', len(self.simDev['publicPasswd'])) + self.simDev['publicPasswd'] + snmpbuff
            snmpbuff = '\x30' + self.coding_of_length(len(snmpbuff)) + snmpbuff
            return snmpbuff
    def coding_obj_and_value(self, obj, val=None):
        temps = ''
        temps += self.coding_obj(obj)
        temps = struct.pack('2B', 0x06, len(temps)) + temps
        if val == None:
            temps += '\x05\x00'
        elif str(type(val)) == '<type \'str\'>':
            temps += '\x04' + struct.pack('B', len(val)) + val
        elif str(type(val)) in ['<type \'int\'>', '<type \'long\'>']:
            if val<=2**7:
                temps += '\x02\x01' + struct.pack('B', val)
            elif 2**7<val<=2**15:
                temps += '\x02\x02' + struct.pack('!H', val)
            elif 2**15<val<=2**23:
                temps += '\x02\x03' + struct.pack('!I', val)[1:]
            elif 2**23<val<=2**31:
                temps += '\x02\x04' + struct.pack('!I', val)  
            else:
                print "value is too big!"
                return
        temps = '\x30' + struct.pack('B', len(temps)) + temps
        return temps 
    def coding_of_length(self, slen):
        #SNMP中域长度的编码方式。此函数直接返回长度字段的编码结果
        if slen<=127:
            return struct.pack('B', slen)
        if 127<slen<256:
            return struct.pack('2B', 0x81, slen)
        if 256<=slen<256**2:
            return struct.pack('!BH', 0x82, slen)            
    def coding_obj(self, obj):
        #将1.3.6.X的OID打包成字节流
        objlist = obj.split('.')
        objtemplist = []
        objfir1byte = int(objlist[0])*40 + int(objlist[1])
        objtemplist.append(struct.pack('B', objfir1byte))
        for i in objlist[2:]:
            if int(i)>127:
                a, b = divmod(int(i), 128)
                objtemplist.append(struct.pack('2B', a+128, b))
            else:
                objtemplist.append(struct.pack('B', int(i)))
        return ''.join(objtemplist)
    
    
def SNMP_server(serverIP = '', passWd = 'public', SNMPPORT = 161):
    usock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    usock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    usock.bind((serverIP, SNMPPORT))
    while 1:
        message, clientaddr = usock.recvfrom(8192)
        req = snmpReqParse(message)
        res = snmpResponse()
        res.reqPublicPasswd = req.publicPasswd
        res.simDev = read_config()[serverIP]
        res.getReqType = req.getReqType
        res.respondID = req.requestID
        res.reqObjList = req.objidList
        resbuff = res.build_snmpbuff()
        if resbuff:
            usock.sendto(resbuff, clientaddr)
            memUsage = res.simDev['usedMem']*100/res.simDev['totalMem']
            diskUsage = res.simDev['usedDisk']*100/res.simDev['totalDisk']
            if not res.error_index:
                print '########### %s ###########\n\
<%s>\n\
>>you request oid are %s\n\
>>server CPU load percentage is : %s\n\
>>server mem used percentage is : %s\n\
>>server disk used percentage is: %s'%(serverIP, time.ctime(), res.reqObjList,
                      res.simDev['CPULOAD'], memUsage, diskUsage)
            
def test_parse():
    global a
    b = a.replace(', 0x', r'\x')
    c = '\\' + b.replace(', \n0x', r'\x')[1:]
    d = c.replace(r'\x', '')
    request = binascii.a2b_hex(d)
    test = snmpReqParse(request)
    print test.simDev('publicPasswd')
    print hex(test.getReqType)
    print test.requestID
    for i in test.objidList:
        print i
def test_response():
    global a
    b = a.replace(', 0x', r'\x')
    c = '\\' + b.replace(', \n0x', r'\x')[1:]
    d = c.replace(r'\x', '')
    request = binascii.a2b_hex(d)
    test = snmpReqParse(request)
    res = snmpResponse('public')
    res.reqPublicPasswd = test.simDev('publicPasswd')
    res.getReqType = test.getReqType
    res.respondID = test.requestID
    res.reqObjList = test.objidList
    resbuff = res.build_snmpbuff()
    print repr(resbuff)
def read_config():
    import ConfigParser
    cf = ConfigParser.ConfigParser()
    cf.read('snmpServer.ini')
    simSers = {}
    for sec in cf.sections():
        simSers[sec] = {'publicPasswd':cf.get(sec, 'password'),
                       'CPULOAD': cf.getint(sec, 'cpuload'),
                       'totalMem':cf.getint(sec, 'totalMem'), 
                       'usedMem':cf.getint(sec, 'usedMem'),
                       'totalDisk':cf.getint(sec, 'totalDisk'), 
                       'usedDisk':cf.getint(sec, 'usedDisk')}
    return simSers
   
def main():
    sersDic = read_config()
    for s in sersDic.keys():
        print repr(s), 'is listening!'
        t = Thread(target=SNMP_server, args=(s, ))
        t.start()
        time.sleep(1)
       
if __name__=='__main__':
    #test_parse()
    #test_response()
    #serverIP = '172.16.1.102'
    #SNMP_server(serverIP)
    print 'start'
    main()
    raw_input('')


以上服务启动依赖配置文件，配置文件中指定模拟的linux或者windows服务器，可以填写多组，文件存为snmpServer.ini

[192.168.10.102]
password = public
cpuload = 11
totalMem = 1024000
usedMem = 102400
totalDisk = 512000000
usedDisk = 100000000

[172.16.1.102]
password = public
cpuload = 30
totalMem = 1024000
usedMem = 204800
totalDisk = 512000000
usedDisk = 300000000



您可能感兴趣的文档:

--结束END--

本文标题: 【测试】python 模拟snmp-se

本文链接: https://lsjlt.com/news/186678.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • 【测试】python 模拟snmp-se
    如下脚本，模拟windows和linux上的snmp-agent，返回数据给snmp请求者。直接上代码吧：# -*- coding: utf-8 -*- import binascii, struct import socket impor...
    99+
    2023-01-31
    测试 python se
  • Android单元测试与模拟测试
    　　考虑可读性，对于方法名使用表达能力强的方法名，对于测试范式可以考虑使用一种规范， 如 RSpec-style。 　　不要使用逻辑流关键字(If/ese、for、do/...
    99+
    2022-06-06
    android单元测试 测试 Android
  • Cacti中文版测试snmp及snmp的解决方法
    本篇内容介绍了“Cacti中文版测试snmp及snmp的解决方法”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！Cacti中文版是用php语言...
    99+
    2023-06-16
  • 详解python并发获取snmp信息及性能测试
    python & snmp 用python获取snmp信息有多个现成的库可以使用，其中比较常用的是netsnmp和pysnmp两个库。网上有较多的关于两个库的例子。 本文重点在于如何并发的获取snmp的数...
    99+
    2022-06-04
    详解 性能测试 信息
  • 使用模拟编写单元测试
    本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《使用模拟编写单元测试》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~问题内容我在里面写了一个rest a...
    99+
    2024-04-04
  • Swift中的HTTP模拟测试示例详解
    目录正文StarWarsAPI 类MockLoader正文 我们已经了解了单个方法如何为通过网络加载请求提供基础。 然而，网络也是开发应用程序时最大的失败点之一，尤其是在单元测试方...
    99+
    2023-02-06
    Swift中的HTTP模拟测试 Swift HTTP
  • python concurrent.futures模块的使用测试
    概述 concurrent.futures 是 3.2 中引入的新模块，它为异步执行可调用对象提供了高层接口。 可以使用 ThreadPoolExecutor 来进行多线程编程，ProcessPoolExecutor...
    99+
    2022-06-02
    python concurrent使用 python concurrent模块
  • python concurrent.futures模块的测试方法
    本篇内容主要讲解“python concurrent.futures模块的测试方法”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“python concurrent.futures模块的测试方法”...
    99+
    2023-06-20
  • stress性能测试模拟CPU使用100%详解
    （1）安装stress 解压：tar -xzvf stress-1.0.4.tar.gz ./configure make make install 默认安装在/usr/lo...
    99+
    2024-04-02
  • 如何利用GitLab进行API测试和模拟
    如何利用GitLab进行API测试和模拟引言：在进行软件开发过程中，API（Application Programming Interface，应用程序编程接口）测试和模拟是非常重要的一步，它可以帮助开发人员验证API的正确性和性能，并且可...
    99+
    2023-10-27
    模拟 gitlab API测试
  • JavaScript Jest 魔术：揭秘模拟和细化测试
    模拟：隔离代码进行测试 模拟允许您创建代码的虚拟替身，模拟其行为而不执行实际实现。这对于隔离代码进行测试非常有用，因为您可以控制模拟行为，而无需依赖外部依赖项或状态。 演示代码： // 创建一个对 fetchData 函数的模拟 con...
    99+
    2024-02-17
    Jest 模拟 细化 测试 JavaScript
  • 如何模拟 rand.Reader 的故障以进行测试？
    知识点掌握了，还需要不断练习才能熟练运用。下面编程网给大家带来一个Golang开发实战，手把手教大家学习《如何模拟 rand.Reader 的故障以进行测试？》，在实现功能的过程中也带大家重新温习相...
    99+
    2024-04-04
  • Go 函数单元测试中的模拟技巧
    单元测试中的模拟是在单元测试中创建测试替身以替换外部依赖项的技术，允许隔离和测试特定函数。基本原则是：定义接口、创建模拟、注入模拟。使用 googlemock 模拟，需要定义接口、创建模...
    99+
    2024-04-30
    go 单元测试 git golang
  • PHP 单元测试中的模拟与桩技术
    在 php 单元测试中，模拟和桩技术可用于：模拟：使用假对象替换依赖项，控制行为并验证交互。桩：创建专门的假接口，验证依赖项的调用情况。模拟可使用 $this->getmockbu...
    99+
    2024-05-06
    php 单元测试
  • python单元测试模块有哪些
    python中的单元测试模块有以下几种nosenose是一个Python的第三方单元测试模块，其兼容unittest，且具有用例编写、用例发现和执行、测试夹具、测试生成器和插件体系等功能。unittestunittest是Python标准库...
    99+
    2024-04-02
  • 如何在 Go 单元测试中模拟 Pulumi 资源？
    问题内容 我有一个函数，它接受 aws openidconnectprovider pulumi 资源的输入并创建一个 iam 角色，并附加一个包含来自该 oidc 提供商的信息的 a...
    99+
    2024-02-06
  • 如何在单元测试 Golang 中模拟 netconf 会话
    问题内容 我正在使用 juniper 的 netconf 包（“github.com/juniper/go-netconf/netconf”）在我的代码中建立 netconf 会话。 ...
    99+
    2024-02-12
  • Go：单元测试中函数的模拟返回值
    在软件开发中，单元测试是一项非常重要的工作，它可以帮助开发者确保代码的质量和可靠性。而在Go语言中，我们可以使用一些库和技术来模拟函数的返回值，以便更好地进行单元测试。本文将由php小...
    99+
    2024-02-10
    go语言 overflow
  • Golang 函数测试中如何模拟真实环境？
    go 函数测试中模拟真实环境的方法：依赖项注入：使用测试双打替换真实依赖项，隔离函数并控制输入。docker 容器：在隔离环境中运行代码，设置确切的依赖项和配置，访问真实的外部服务。 ...
    99+
    2024-04-16
    golang 函数测试 redis docker
  • RedFlagLinuxRCE模拟试题(
    10. 下面有关IP地址叙述错误的是：   A. 用32Bits表示，其分配独立与机器的物理硬件地址。   B. 0.0.0.0表示本主机，但该地址只在系统启动的时候允许使用。   *C. 0.0.0.1表示本...
    99+
    2023-01-31
    模拟试题 RedFlagLinuxRCE
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作