def test_init(self):
type_set = RxTypeSet()
char_sets = CharSets(type_set)
self.assertEqual(len(char_sets._char_sets), len(CHAR_SETS.keys()))
for key in CHAR_SETS.keys():
self.assertIn(key, char_sets._char_sets)
self.assertIsInstance(char_sets._char_sets[key], set)
self.assertEqual(len(char_sets._char_sets[key]), 0)
self.assertEqual(type_set, char_sets._rxtypes)
def init_wrappers(self,
printable_subset: Optional[Iterable[str]] = None
) -> None:
if not printable_subset:
printable_subset = CHAR_SETS.keys()
printable_subset = set(printable_subset)
# clear containers
self._wrappers.clear()
self._char_sets.empty_sets()
for settings in RXWRAPPER_SETTINGS:
settings["rxtype_name"] = settings.get("rxtype_name",
settings["name"])
if settings.get("is_char_set"):
type_name = settings.get("rxtype_name", settings["name"])
char_set = settings.get("char_set") or CHAR_SETS[type_name]
self._char_sets.init_char_set(type_name, printable_subset,
char_set)
for char in char_set:
settings["char_value"] = char
self.add(self.create_wrapper(**settings))
else:
self.add(self.create_wrapper(**settings))
def test_init_char_set(self):
type_set = RxTypeSet()
type_set.init_types()
char_sets = CharSets(type_set)
printable_subset = set(CHAR_SETS.keys())
for settings in RXWRAPPER_SETTINGS:
if settings.get("is_char_set"):
type_name = settings.get("rxtype_name", settings["name"])
char_set = settings.get("char_set") or CHAR_SETS[type_name]
char_sets.init_char_set(type_name, printable_subset, char_set)
for type_name in CHAR_SETS.keys():
self.assertIn(type_name, char_sets._char_sets)
for char in CHAR_SETS[type_name]:
self.assertIn(char, char_sets._char_sets[type_name])
def test_invert_set(self):
mock_node = MockNode(char_sets=self.char_sets)
for char_set_name in CHAR_SETS.keys():
char_set = list(
self.char_sets[char_set_name]) # CHAR_SETS[char_set_name]
subset = set([random.choice(char_set) for i in range(5)])
result = invert_set(mock_node, subset, char_set_name)
self.assertEqual(len(result) + len(subset), len(char_set))
self.assertSetEqual(result | subset, set(char_set))
def test_empty_sets(self):
type_set = RxTypeSet()
char_sets = CharSets(type_set)
for key in char_sets._char_sets.keys():
char_sets._char_sets[key].add("a")
char_sets._char_sets[key].add("b")
char_sets._char_sets[key].add("c")
self.assertEqual(len(char_sets._char_sets[key]), 3)
char_sets.empty_sets()
self.assertEqual(len(char_sets._char_sets), len(CHAR_SETS.keys()))
for key in char_sets._char_sets.keys():
self.assertEqual(len(char_sets._char_sets[key]), 0)
def test_init_char_set_full_subset(self):
type_set = RxTypeSet()
type_set.init_types()
char_sets = CharSets(type_set)
type_name = "alphanum"
full_type_names = set(type_set.get_full_type_names(type_name))
printable_subset = set(CHAR_SETS.keys())
char_set = CHAR_SETS[type_name]
char_sets.init_char_set(type_name, printable_subset, char_set)
# all related type names should contain all characters in alphanum char set
for char in char_set:
for name in full_type_names:
# only evaluate those type names that represent actual printable character sets
if name in char_sets._char_sets:
self.assertIn(char, char_sets._char_sets[name])
def gen_test_no_match(
self,
prob_alphanum: Optional[float] = None,
prob_data_format: Optional[float] = None,
data_format: Optional[dict] = None,
char_sets: Optional[Sequence[str]] = None,
) -> str:
prob_alphanum = prob_alphanum or 0.5
prob_data_format = prob_data_format or 0.5
if not data_format:
prob_data_format = 0
data_format = {}
if not char_sets:
char_sets = list(CHAR_SETS.keys())
use_data_format: bool = random() < prob_data_format
num_words: int = select_index(MAX_WORDS) + 1
if random() < prob_alphanum:
char_set_name: str = "alphanum"
else:
char_set_name = choice(char_sets)
if use_data_format:
num_words = callable_get(data_format.get("num_words",
None)) or num_words
char_set_name = (callable_get(data_format.get("char_set", None))
or char_set_name)
char_set: str = CHAR_SETS[char_set_name]
res: List[str] = []
for i in range(num_words):
num_chars: int = select_index(10) + 1
if use_data_format:
num_chars = (callable_get(data_format.get("word_length", None),
i) or num_chars)
res.append("".join([choice(char_set) for i in range(num_chars)]))
return " ".join(res)
def __init__(self, rxtypes: RxTypeSet) -> None:
self._char_sets: Dict[str,
Set[str]] = {c: set()
for c in CHAR_SETS.keys()}
self._rxtypes: RxTypeSet = rxtypes
def test_contains_true(self):
type_set = RxTypeSet()
char_sets = CharSets(type_set)
for key in CHAR_SETS.keys():
self.assertTrue(key in char_sets)
self.assertIn(key, char_sets)
def test_getitem(self):
type_set = RxTypeSet()
char_sets = CharSets(type_set)
for key in CHAR_SETS.keys():
self.assertIsInstance(char_sets[key], set)