class IntegerEdgeCases
(Muta
tor
):
"""
Generate integer edge cases. The
numbers produced are distributed over a bell curve with
the edge case as the center.
"""
def __init__
(self, obj, rand
):
Muta
tor.__init__
(self
)
min_, max_ = self.get_limits
(obj
)
delta = max_ - min_
if 0xff >= delta >= 0:
# We are <= a single byte, set the space size of the
range
self.space = delta +
1
self.full_space = self.space
def sequential
():
return min_ + self.mutation_index
def
random():
return rand.randint
(min_, max_
)
self.sequential_genera
tor = sequential
self.
random_genera
tor =
random
else:
# For more than a single byte, use edge case genera
tor
self.genera
tor = EdgeCaseGenera
tor
(min_, max_
)
self.space = len
(self.genera
tor.values
)
self.full_space = self.genera
tor.deviation
def sequential
():
return self.genera
tor.values[self.mutation_index]
def
random():
return self.genera
tor.gen_next
(rand
)
self.sequential_genera
tor = sequential
self.
random_genera
tor =
random
def get_limits
(self, obj
):
"""
Get the minimum and maximum values
to generate edge cases for.
:param obj: The element this muta
tor is bound
to.
:return: The minimum value of the number space, The maximum value of the number space.
"""
return 0, sys.maxsize
def perform_mutation
(self, obj, value
):
"""
Mutate the data element.
:param obj: The element
to mutate.
:param value: The value
to use when mutating.
:return:
"""
pass
def mutate
(self, obj, gen
):
value = gen
()
self.perform_mutation
(obj, value
)
def sequential_mutation
(self, obj
):
self.mutate
(obj, self.sequential_genera
tor
)
def
random_mutation
(self, obj
):
self.mutate
(obj, self.
random_genera
tor
)
def get_count
(self
):
return self.space
class EdgeCaseGenera
tor:
"""
Computes the edge cases of
numbers inside a given space.
"""
SCHAR_MIN = -
128
SCHAR_MAX =
12
7
UCHAR_MAX = 2
55
CHAR_MIN = -
128
CHAR_MAX =
12
7
SHRT_MIN = -32
768
SHRT_MAX = 32
76
7
USHRT_MAX = 6
553
5
INT_MIN = -2
14
748364
7 -
1
INT_MAX = 2
14
748364
7
UINT_MAX = 429496
729
5
LONG_MIN = -2
14
748364
7 -
1
LONG_MAX = 2
14
748364
7
ULONG_MAX = 429496
729
5
LLONG_MIN = -92233
720368
54
77580
7 -
1
LLONG_MAX = 92233
720368
54
77580
7
ULLONG_MAX =
18446
7440
73
709
5516
15
EDGES = [SCHAR_MIN, SCHAR_MAX, UCHAR_MAX, CHAR_MIN, CHAR_MAX, SHRT_MIN, SHRT_MAX, USHRT_MAX,
INT_MIN, INT_MAX, UINT_MAX, LONG_MIN, LONG_MAX, ULONG_MAX, LLONG_MIN, LLONG_MAX, ULLONG_MAX, 0]
# The maximum
range to pick
numbers around each edge
max_
range = 0x4000
def __init__
(self, min_num, max_num
):
# The list of edge cases in the number space.
self.edges = self.EDGES
self.min_num = min_num
self.max_num = max_num
self.edges = [num for num in self.edges if max_num >= num >= min_num]
self.edges.append
(min_num
)
self.edges.append
(max_num
)
self.edges = list
(set
(self.edges
))
self.edges.sort
()
self.
ranges = []
self.stddev = []
self.weights = []
# The sum of all the standard deviations at each edge case
self.deviation = 0
# Precomputed list of values for sequential muta
tor
self.values = []
# Compute
range and standard deviation
for i in
range(len
(self.edges
)):
edge = self.edges[i]
if edge <= 0 and edge != max_num:
# If edge <= 0, it is the distance
to next edge
v = self.edges[i +
1] - edge
else:
# If edge > 0, it is the distance
to the previous edge
v = edge - self.edges[i -
1]
# Cap the +/-
range to a maximum
v = min
(v, self.max_
range)
self.
ranges.append
(v
)
# We want the distribution
to be a bell curve over
# 2x the
range. This means stddev should be 2*
range / 6
# since 99% of the
numbers will be 3 stddev away
from the mean
# Also, round up so if v is < 3, we get at least
1
sigma = float
(v + 2
) / 3
self.stddev.append
(sigma
)
# The
1st and last edge get
1/2 the weight since they are half curves
# We still s
tore the full deviation but do an abs
() of the next rng
if i == 0 or i == len
(self.edges
) -
1:
# Round up so we always have a valid stddev
sigma =
(sigma +
1) / 2
self.deviation += sigma
# Weight each edge based on its
range
sum_ = 0
for i in
range(len
(self.edges
)):
weight =
1.0 -
(1.0 * sum_ / self.deviation
)
self.weights.append
(weight
)
s = self.stddev[i]
# The
1st and last edge get
1/2 the weight since they are half curves
# We still s
tore the full deviation but do an abs
() of the next rng
if i == 0 or i == len
(self.edges
) -
1:
s /= 2
sum_ += s
# Compute a list of +/- delta around each edge
for i in
range(len
(self.edges
)):
if i != 0:
for j in
range(-
50, 0
):
self.values.append
(self.edges[i] + j
)
self.values.append
(self.edges[i]
)
if i != len
(self.edges
) -
1:
for j in
range(1,
51):
self.values.append
(self.edges[i] + j
)
def
range(self, edge_index
):
return self.
ranges[edge_index]
def gen_next
(self, rand
):
r = rand.
random()
i = len
(self.weights
) -
1
while self.weights[i] <= r:
i -=
1
edge = self.edges[i]
sigma = self.stddev[i]
while True:
num = rand.gauss
(0,
1)
if
(num < 0 and edge == self.min_num
) or
(num > 0 and edge == self.max_num
):
num *= -
1
num = num * sigma
if edge == self.min_num:
num = math.floor
(num
)
elif edge == self.max_num:
num = math.ceil
(num
)
else:
num = round
(num
)
ret = edge + int
(num
)
if self.max_num >= ret >= self.min_num:
return int
(ret
)这是python版本代码，我要转为cpp版本，下面是已经完成的部分#ifndef MUTA
TOR_STRINGLENGTHEDGECASE_H
#define MUTA
TOR_STRINGLENGTHEDGECASE_H
#include <vec
tor>
#include <memory>
#include "../utils.h"
#include "../../data_types/string_.h"
#include "../base.h"
class StringLengthEdgeCase : public IntegerEdgeCases {
public:
StringLengthEdgeCase
(std::shared_ptr<StringBase> obj, std::mt
1993
7 &rand
);
std::pair<int64_t, int64_t> get_limits
(std::shared_ptr<StringBase> obj
) override;
std::vec
tor<std::shared_ptr<StringBase>> mutated_elements;
void perform_mutation
(std::shared_ptr<StringBase> obj, std::string value
) override;
void sequential_mutation
(std::shared_ptr<StringBase> obj
) override;
void
random_muatation
(std::shared_ptr<StringBase> obj
) override;
bool supported
(std::shared_ptr<StringBase> obj
) override;
private:
};
#endif //MUTA
TOR_STRINGLENGTHEDGECASE_H
#include "StringLengthEdgeCase.h"
#include <algorithm>
#include "../utils.h"
StringLengthEdgeCase::StringLengthEdgeCase
(std::shared_ptr<StringBase> obj, std::mt
1993
7 &rand
) : IntegerEdgeCases
(obj, rand
) {}
std::pair<int64_t, int64_t> StringLengthEdgeCase::get_limits
(std::shared_ptr<StringBase> obj
) {
int64_t max_ = obj->muta
tor_config.max_output_size * 8;
int64_t size = obj->calculate_bit_size
();
int64_t limit = std::max
(max_, size
);
limit =
(limit +
7) / 8;
max_ = limit;
if
(obj->max_length != -INT64_MAX
) {
max_ = std::min
(max_, obj->max_length
);
}
int64_t min_ = 0;
if
(obj->min_length != INT64_MAX
) {
min_ = std::max
(min_, obj->min_length
);
}
return {min_, max_};
}
bool StringLengthEdgeCase::supported
(std::shared_ptr<StringBase> obj
) {
return std::dynamic_pointer_cast<String>
(obj
) != nullptr;
}
void StringLengthEdgeCase::perform_mutation
(std::shared_ptr<StringBase> obj, std::string value
) {
uint64_t valueLength = value.size
();
obj->mutated_value =
expand(obj->value, valueLength
);
obj->mutated = true;
mutated_elements.push_back
(obj
);
}
void StringLengthEdgeCase: 使用的基类我已经完成，需要在当前代码中针对StringLengthEdgeCase重写一下sequential_mutation和
random_muatation对面
本文介绍了一个利用已有的1到5范围内的随机数生成器来创建1到7范围内随机数的方法。通过构建一个5x5的矩阵，每次调用两次1到5的随机数生成器来获取矩阵中的值，直到返回一个1到7之间的有效随机数。
扫一扫
604
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
