wlauto.tests package

Submodules

wlauto.tests.test_agenda module

class wlauto.tests.test_agenda.AgendaTest(methodName='runTest')

Bases: unittest.case.TestCase

test_bad_syntax(*arg, **kw)

test_default_id_assignment()

test_defaults()

test_dup_sections(*arg, **kw)

test_duplicate_id()

test_sections()

test_yaml_load()

test_yaml_missing_field()

wlauto.tests.test_config module

class wlauto.tests.test_config.ConfigLoaderTest(methodName='runTest')

Bases: unittest.case.TestCase

setUp()

tearDown()

test_load()

test_load_bad(*arg, **kw)

test_load_duplicate()

class wlauto.tests.test_config.ConfigTest(methodName='runTest')

Bases: unittest.case.TestCase

setUp()

test_case()

test_exetension_params_lists()

test_global_instrumentation()

test_instrumentation_specification()

test_list_defaults_params()

test_remove_instrument()

class wlauto.tests.test_config.DefaultsWorkload

Bases: object

class wlauto.tests.test_config.ListParamstrument

Bases: object

class wlauto.tests.test_config.MockAgenda(*args)

Bases: object

class wlauto.tests.test_config.MockExtensionLoader

Bases: object

get_default_config(name)

get_extension_class(name, kind=None)

has_extension(name)

resolve_alias(name)

class wlauto.tests.test_config.NamedMock(name)

Bases: object

wlauto.tests.test_device module

class wlauto.tests.test_device.RuntimeParametersTest(methodName='runTest')

Bases: unittest.case.TestCase

test_bad_runtime_param(*arg, **kw)

test_core_param()

test_get_unset_runtime_params()

test_param_set_order()

test_runtime_param()

class wlauto.tests.test_device.TestDevice(*args, **kwargs)

Bases: wlauto.core.device.Device

aliases = AC([])

artifacts = AC([])

core_getter(core)

core_modules = []

core_setter(core, value)

dynamic_modules = AC([])

finalize(*args, **kwargs)

getter()

initialize(*args, **kwargs)

name = 'test-device'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'_overridden': 'TestDevice', 'kind': <class 'wlauto.utils.types.list_of_caseless_strings'>, 'mandatory': True, 'name': 'core_names', 'constraint': None, 'default': ['a7', 'a7', 'a15'], 'allowed_values': None, 'global_alias': None, 'override': True})", "Param({'_overridden': 'TestDevice', 'kind': <function list_of_ints>, 'mandatory': True, 'name': 'core_clusters', 'constraint': None, 'default': [0, 0, 1], 'allowed_values': None, 'global_alias': None, 'override': True})"])

path_module = 'posixpath'

runtime_parameters = AC(['test_param', 'test_param2', '${core}_param'])

setter(value)

validate(*args, **kwargs)

wlauto.tests.test_diff module

class wlauto.tests.test_diff.InterruptDiffTest(methodName='runTest')

Bases: unittest.case.TestCase

test_interrupt_diff()

wlauto.tests.test_execution module

class wlauto.tests.test_execution.BadDevice(when_to_fail, exception=<class 'wlauto.exceptions.DeviceError'>)

Bases: wlauto.core.device.Device

aliases = AC([])

artifacts = AC([])

connect()

core_modules = []

disconnect()

dynamic_modules = AC([])

finalize(*args, **kwargs)

get_properties(_)

initialize(*args, **kwargs)

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <class 'wlauto.utils.types.list_of_caseless_strings'>, 'mandatory': True, 'name': 'core_names', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <function list_of_ints>, 'mandatory': True, 'name': 'core_clusters', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

ping()

runtime_parameters = AC([])

set_device_parameters(**_)

start()

stop()

validate(*args, **kwargs)

class wlauto.tests.test_execution.BadDeviceMeta

Bases: wlauto.core.device.DeviceMeta

class wlauto.tests.test_execution.BadWorkload(exception, when_to_fail)

Bases: wlauto.core.workload.Workload

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

run(_)

setup(_)

teardown(_)

update_result(_)

validate(*args, **kwargs)

class wlauto.tests.test_execution.Mock

Bases: object

class wlauto.tests.test_execution.RunnerTest(methodName='runTest')

Bases: unittest.case.TestCase

bad_device(method)

errors = 0

signal_check(expected_signals, workloads, reboot_policy='never', runner_class=<class 'wlauto.core.execution.BySpecRunner'>)

test_CTRL_C()

test_bad_connect(*arg, **kw)

test_bad_disconnect()

test_bad_get_properties(*arg, **kw)

test_bad_initialize(*arg, **kw)

test_bad_start()

test_bad_stop()

test_bad_workload_status()

test_multiple_run_byiteration()

test_multiple_run_byspec()

test_no_teardown_after_setup_fail()

test_reboot_policies()

test_single_run()

test_spec_skipping()

test_teardown_on_run_and_result_update_fail()

class wlauto.tests.test_execution.SignalCatcher

Bases: wlauto.core.instrumentation.Instrument

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

handler(*_, **kwargs)

initialize(*args, **kwargs)

name = 'Signal Catcher'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

wlauto.tests.test_extension module

class wlauto.tests.test_extension.ExtensionMetaTest(methodName='runTest')

Bases: unittest.case.TestCase

test_duplicate_param_spec(*arg, **kw)

test_initialization()

test_initialization_happens_once()

test_invalid_param_spec(*arg, **kw)

test_param_override()

test_propagation()

test_virtual_methods()

class wlauto.tests.test_extension.FakeLoader

Bases: object

get_module(name, owner, **kwargs)

modules = [<class 'wlauto.tests.test_extension.MyCoolModule'>, <class 'wlauto.tests.test_extension.MyEvenCoolerModule'>]

class wlauto.tests.test_extension.ModuleTest(methodName='runTest')

Bases: unittest.case.TestCase

test_fizzle()

test_self_fizzle()

class wlauto.tests.test_extension.MultiValueParamExt(**kwargs)

Bases: wlauto.core.extension.Extension

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'multivalue'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <function list_of_ints>, 'mandatory': None, 'name': 'test', 'constraint': None, 'default': None, 'allowed_values': [42, 7, 73], 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

class wlauto.tests.test_extension.MyAcidExtension(**kwargs)

Bases: wlauto.tests.test_extension.MyBaseExtension

aliases = AC([])

artifacts = AC([])

core_modules = []

name = 'acid'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <type 'str'>, 'mandatory': None, 'name': 'base', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <function list_of_ints>, 'mandatory': None, 'name': 'hydrochloric', 'constraint': None, 'default': [1, 2], 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <type 'str'>, 'mandatory': None, 'name': 'citric', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <function integer>, 'mandatory': None, 'name': 'carbonic', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

virtual1(*args, **kwargs)

virtual2(*args, **kwargs)

class wlauto.tests.test_extension.MyBaseExtension(**kwargs)

Bases: wlauto.core.extension.Extension

aliases = AC([])

artifacts = AC([])

core_modules = []

name = 'base'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <type 'str'>, 'mandatory': None, 'name': 'base', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

virtual1(*args, **kwargs)

virtual2(*args, **kwargs)

class wlauto.tests.test_extension.MyCoolModule(owner, **kwargs)

Bases: wlauto.core.extension.Module

aliases = AC([])

artifacts = AC([])

capabilities = ['fizzle']

core_modules = []

finalize(*args, **kwargs)

fizzle()

initialize(*args, **kwargs)

name = 'cool_module'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

class wlauto.tests.test_extension.MyEvenCoolerModule(owner, **kwargs)

Bases: wlauto.core.extension.Module

aliases = AC([])

artifacts = AC([])

capabilities = ['fizzle']

core_modules = []

finalize(*args, **kwargs)

fizzle()

initialize(*args, **kwargs)

name = 'even_cooler_module'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

class wlauto.tests.test_extension.MyMeta

Bases: wlauto.core.extension.ExtensionMeta

virtual_methods = ['validate', 'virtual1', 'virtual2']

class wlauto.tests.test_extension.MyModularExtension(**kwargs)

Bases: wlauto.core.extension.Extension

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'modular'

parameters = AC(["Param({'_overridden': 'MyModularExtension', 'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': ['cool_module'], 'allowed_values': None, 'global_alias': None, 'override': True})"])

validate(*args, **kwargs)

class wlauto.tests.test_extension.MyOtherExtension(**kwargs)

Bases: wlauto.tests.test_extension.MyBaseExtension

aliases = AC([])

artifacts = AC([])

core_modules = []

name = 'other'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <type 'str'>, 'mandatory': None, 'name': 'base', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <type 'str'>, 'mandatory': True, 'name': 'mandatory', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <type 'str'>, 'mandatory': None, 'name': 'optional', 'constraint': None, 'default': None, 'allowed_values': ['test', 'check'], 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

virtual1(*args, **kwargs)

virtual2(*args, **kwargs)

class wlauto.tests.test_extension.MyOtherModularExtension(**kwargs)

Bases: wlauto.core.extension.Extension

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'other_modular'

parameters = AC(["Param({'_overridden': 'MyOtherModularExtension', 'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': ['cool_module', 'even_cooler_module'], 'allowed_values': None, 'global_alias': None, 'override': True})"])

validate(*args, **kwargs)

class wlauto.tests.test_extension.MyOtherOtherExtension(**kwargs)

Bases: wlauto.tests.test_extension.MyOtherExtension

aliases = AC([])

artifacts = AC([])

core_modules = []

name = 'otherother'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <type 'str'>, 'mandatory': None, 'name': 'base', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'_overridden': 'MyOtherOtherExtension', 'kind': <type 'str'>, 'mandatory': True, 'name': 'mandatory', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': True})", "Param({'kind': <type 'str'>, 'mandatory': None, 'name': 'optional', 'constraint': None, 'default': None, 'allowed_values': ['test', 'check'], 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

virtual1(*args, **kwargs)

virtual2(*args, **kwargs)

class wlauto.tests.test_extension.MyOverridingExtension(**kwargs)

Bases: wlauto.tests.test_extension.MyAcidExtension

aliases = AC([])

artifacts = AC([])

core_modules = []

name = 'overriding'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <type 'str'>, 'mandatory': None, 'name': 'base', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'_overridden': 'MyOverridingExtension', 'kind': <function list_of_ints>, 'mandatory': None, 'name': 'hydrochloric', 'constraint': None, 'default': [3, 4], 'allowed_values': None, 'global_alias': None, 'override': True})", "Param({'kind': <type 'str'>, 'mandatory': None, 'name': 'citric', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <function integer>, 'mandatory': None, 'name': 'carbonic', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

virtual1(*args, **kwargs)

virtual2(*args, **kwargs)

class wlauto.tests.test_extension.MyThirdTeerExtension(**kwargs)

Bases: wlauto.tests.test_extension.MyOverridingExtension

aliases = AC([])

artifacts = AC([])

core_modules = []

name = 'thirdteer'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <type 'str'>, 'mandatory': None, 'name': 'base', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'_overridden': 'MyOverridingExtension', 'kind': <function list_of_ints>, 'mandatory': None, 'name': 'hydrochloric', 'constraint': None, 'default': [3, 4], 'allowed_values': None, 'global_alias': None, 'override': True})", "Param({'kind': <type 'str'>, 'mandatory': None, 'name': 'citric', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})", "Param({'kind': <function integer>, 'mandatory': None, 'name': 'carbonic', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

virtual1(*args, **kwargs)

virtual2(*args, **kwargs)

class wlauto.tests.test_extension.ParametersTest(methodName='runTest')

Bases: unittest.case.TestCase

test_bad_multivalue_param(*arg, **kw)

test_default_override()

test_duplicate_param_override(*arg, **kw)

test_multivalue_param()

test_overriding_new_param(*arg, **kw)

test_setting()

test_validation_bad_value(*arg, **kw)

test_validation_no_mandatory(*arg, **kw)

test_validation_no_mandatory_in_derived(*arg, **kw)

test_validation_ok()

wlauto.tests.test_extension_loader module

class wlauto.tests.test_extension_loader.ExtensionLoaderTest(methodName='runTest')

Bases: unittest.case.TestCase

test_clear_and_reload()

test_list_by_kind()

test_load_device()

wlauto.tests.test_instrumentation module

class wlauto.tests.test_instrumentation.BadInstrument

Bases: wlauto.core.instrumentation.Instrument

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'bad'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

teardown()

validate(*args, **kwargs)

class wlauto.tests.test_instrumentation.InstrumentationTest(methodName='runTest')

Bases: unittest.case.TestCase

install_local_instrument()

tearDown()

test_bad_argspec(*arg, **kw)

test_check_enabled()

test_check_installed()

test_duplicate_install(*arg, **kw)

test_enable_disable()

test_install()

test_local_instrument()

test_priority_prefix_instrument()

class wlauto.tests.test_instrumentation.MockInstrument

Bases: wlauto.core.instrumentation.Instrument

after_workload_execution(context)

aliases = AC([])

artifacts = AC([])

before_workload_execution(context)

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'mock'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

class wlauto.tests.test_instrumentation.MockInstrument2

Bases: wlauto.core.instrumentation.Instrument

after_workload_execution(context)

after_workload_result_update(context)

aliases = AC([])

artifacts = AC([])

before_workload_execution(context)

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'mock_2'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

class wlauto.tests.test_instrumentation.MockInstrument3

Bases: wlauto.core.instrumentation.Instrument

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'mock_3'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

slow_before_workload_execution(context)

validate(*args, **kwargs)

class wlauto.tests.test_instrumentation.MockInstrument4

Bases: wlauto.core.instrumentation.Instrument

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'mock_4'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

slow_before_first_iteration_boot(context)

validate(*args, **kwargs)

class wlauto.tests.test_instrumentation.MockInstrument5

Bases: wlauto.core.instrumentation.Instrument

aliases = AC([])

artifacts = AC([])

core_modules = []

fast_before_first_iteration_boot(context)

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'mock_5'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

class wlauto.tests.test_instrumentation.MockInstrument6

Bases: wlauto.core.instrumentation.Instrument

aliases = AC([])

artifacts = AC([])

before_first_iteration_boot(context)

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'mock_6'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

validate(*args, **kwargs)

wlauto.tests.test_results_manager module

class wlauto.tests.test_results_manager.MockResultProcessor1(**kwargs)

Bases: wlauto.core.result.ResultProcessor

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'result_processor_with_exception'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

process_iteration_result(result, context)

process_run_result(result, context)

validate(*args, **kwargs)

class wlauto.tests.test_results_manager.MockResultProcessor2(**kwargs)

Bases: wlauto.core.result.ResultProcessor

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'result_processor_with_wa_error'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

process_iteration_result(result, context)

process_run_result(result, context)

validate(*args, **kwargs)

class wlauto.tests.test_results_manager.MockResultProcessor3(**kwargs)

Bases: wlauto.core.result.ResultProcessor

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'result_processor_with_keybaord_interrupt'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

process_iteration_result(result, context)

process_run_result(result, context)

validate(*args, **kwargs)

class wlauto.tests.test_results_manager.MockResultProcessor4

Bases: wlauto.core.result.ResultProcessor

aliases = AC([])

artifacts = AC([])

core_modules = []

finalize(*args, **kwargs)

initialize(*args, **kwargs)

name = 'result_processor'

parameters = AC(["Param({'kind': <type 'list'>, 'mandatory': None, 'name': 'modules', 'constraint': None, 'default': None, 'allowed_values': None, 'global_alias': None, 'override': False})"])

process_iteration_result(result, context)

process_run_result(result, context)

validate(*args, **kwargs)

class wlauto.tests.test_results_manager.ResultManagerTest(methodName='runTest')

Bases: unittest.case.TestCase

test_add_result()

test_keyboard_interrupt()

test_process_results()

wlauto.tests.test_utils module

class wlauto.tests.test_utils.TestCheckOutput(methodName='runTest')

Bases: unittest.case.TestCase

test_bad(*arg, **kw)

test_ok()

class wlauto.tests.test_utils.TestMerge(methodName='runTest')

Bases: unittest.case.TestCase

test_dict_merge()

test_merge_dict_lists()

test_merge_lists()

test_type_mismatch(*arg, **kw)

class wlauto.tests.test_utils.TestParameterDict(methodName='runTest')

Bases: unittest.case.TestCase

orig_params = {'none': None, 'string': 'A Test String', 'int': 42, 'float': 1.23, 'long': 987L, 'string_list': ['A Test', 'List', 'With', '\n in.'], 'bool_list': [False, True, True]}

setUp()

test_contains()

test_get()

test_getEncodedItems()

test_getitem()

test_iteritems()

test_parameter_dict_update()

test_pop()

class wlauto.tests.test_utils.TestTypes(methodName='runTest')

Bases: unittest.case.TestCase

test_arguments()

test_caseless_string()

test_list_or_conversion()

Module contents