Tests

Tests: test_aux_tools

'''Unit tests for fluidsolve.aux_tools.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring

import inspect
import pytest
import fluidsolve.aux_tools as module_under_test

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['GetArgs', 'vFun'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

@pytest.mark.parametrize('name', ['getPumpCurveDataText', 'prepareArgs', 'spec', 'toUnits'])
def test_public_functions_are_callable(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert callable(obj)

def test_toUnits_scalar_to_quantity() -> None:
  q = module_under_test.toUnits(2, module_under_test.u.m)
  assert q.magnitude == 2
  assert q.units == module_under_test.u.m

def test_toUnits_quantity_conversion_and_magnitude() -> None:
  value = 250 * module_under_test.u.cm
  out = module_under_test.toUnits(value, module_under_test.u.m, magnitude=True)
  assert out == 2.5

def test_toUnits_none_value_raises() -> None:
  with pytest.raises(ValueError, match='Value is None'):
    module_under_test.toUnits(None, module_under_test.u.m)  # type: ignore[arg-type]

def test_toUnits_returns_value_unchanged_when_units_none() -> None:
  value = 5
  assert module_under_test.toUnits(value, None) == value  # type: ignore[arg-type]

def test_prepareArgs_filters_none_values() -> None:
  args = module_under_test.prepareArgs(a=1, b=None, c='x')
  assert args == {'a': 1, 'c': 'x'}

def test_getPumpCurveDataText_parses_whitespace_and_commas() -> None:
  data = '''
    1, 2
    3 4
  '''
  assert module_under_test.getPumpCurveDataText(data) == [1.0, 2.0, 3.0, 4.0]

def test_getPumpCurveDataText_empty_string_returns_empty_list() -> None:
  assert module_under_test.getPumpCurveDataText('') == []

def test_spec_returns_input_kwargs_as_dict() -> None:
  out = module_under_test.spec(comp='Tube', nodes=['A', 'B'], sense=-1, D=50)
  assert out == {'comp': 'Tube', 'nodes': ['A', 'B'], 'sense': -1, 'D': 50}

def test_getargs_with_validators_and_remove() -> None:
  args = module_under_test.GetArgs({'name': '  abc  '})
  result = args.getArg('name', [module_under_test.vFun.stripspaces(), module_under_test.vFun.toupper()])
  assert result == 'ABC'
  assert args.restArgs() == {}

def test_getargs_init_rejects_non_dict() -> None:
  with pytest.raises(TypeError, match='is not a dict'):
    module_under_test.GetArgs([('name', 'abc')])  # type: ignore[arg-type]

def test_getargs_getarg_keeps_value_when_remove_false() -> None:
  args = module_under_test.GetArgs({'name': 'abc'})
  result = args.getArg('name', remove=False)
  assert result == 'abc'
  assert args.restArgs() == {'name': 'abc'}

def test_getargs_invalid_name_type_raises() -> None:
  args = module_under_test.GetArgs({'name': 'abc'})
  with pytest.raises(TypeError, match='name argument 1 is not a str'):
    args.getArg(1)  # type: ignore[arg-type]

def test_getargs_invalid_validators_type_raises() -> None:
  args = module_under_test.GetArgs({'name': 'abc'})
  with pytest.raises(TypeError, match='validators argument .* is not a list'):
    args.getArg('name', module_under_test.vFun.stripspaces())  # type: ignore[arg-type]

def test_getargs_non_function_validator_raises() -> None:
  args = module_under_test.GetArgs({'name': 'abc'})
  with pytest.raises(TypeError, match='is not a function'):
    args.getArg('name', ['not-a-function'])  # type: ignore[list-item]

def test_getargs_addarg_and_addargs_preserve_existing_values() -> None:
  args = module_under_test.GetArgs({'a': 1})
  args.addArg('b', 2)
  args.addArgs({'b': 99, 'c': 3})
  assert args.restArgs() == {'a': 1, 'b': 2, 'c': 3}

def test_getargs_isempty_behaviour_matches_current_contract() -> None:
  empty_args = module_under_test.GetArgs({})
  assert empty_args.isEmpty() is False

  remaining_args = module_under_test.GetArgs({'left': 1})
  assert remaining_args.isEmpty(raiseerror=False) is True
  with pytest.raises(TypeError, match='argument left'):
    remaining_args.isEmpty()

def test_getargs_default_when_missing() -> None:
  args = module_under_test.GetArgs({})
  result = args.getArg('speed', [module_under_test.vFun.default(2900)])
  assert result == 2900

def test_getargs_missing_without_default_raises() -> None:
  args = module_under_test.GetArgs({})
  with pytest.raises(ValueError, match='Name speed not found'):
    args.getArg('speed', [module_under_test.vFun.istype(int)])

def test_vfun_istype_rejects_wrong_type() -> None:
  validator = module_under_test.vFun.istype(int)
  with pytest.raises(ValueError, match='not of type'):
    validator('n', '3')

def test_vfun_totype_casts_and_respects_optional_none() -> None:
  validator = module_under_test.vFun.totype(int)
  assert validator('n', '3') == 3
  optional_validator = module_under_test.vFun.totype(int, need=False)
  assert optional_validator('n', None) is None

def test_vfun_case_converters_and_stripspaces_allow_optional_none() -> None:
  assert module_under_test.vFun.stripspaces()('name', '  a b  ') == 'a b'
  assert module_under_test.vFun.tolower()('name', 'AbC') == 'abc'
  assert module_under_test.vFun.toupper(need=False)('name', None) is None

def test_vfun_tounits_converts_and_handles_none_modes() -> None:
  validator = module_under_test.vFun.tounits(module_under_test.u.cm, magnitude=True)
  assert validator('length', 2) == 2
  with pytest.raises(ValueError, match='Argument is None'):
    module_under_test.vFun.tounits(module_under_test.u.cm)('length', None)
  assert module_under_test.vFun.tounits(module_under_test.u.cm, need=False)('length', None) is None

def test_vfun_sanitizefilepath_and_tolambda_transform() -> None:
  validator = module_under_test.vFun.sanitizefilepath()
  assert validator('path', 'a/../b\\file.txt') == module_under_test.os.path.normpath('a/../b\\file.txt')
  lambda_validator = module_under_test.vFun.tolambda(lambda value: value * 2)
  assert lambda_validator('n', 4) == 8
  assert module_under_test.vFun.tolambda(lambda value: value, need=False)('n', None) is None

def test_vfun_istype_accepts_tuple_and_custom_message() -> None:
  validator = module_under_test.vFun.istype((int, float))
  assert validator('n', 3.5) == 3.5
  with pytest.raises(ValueError, match='bad type'):
    module_under_test.vFun.istype(int, errmsg='bad type')('n', '3')

def test_vfun_notnone_and_notempty_raise_custom_messages() -> None:
  with pytest.raises(ValueError, match='required'):
    module_under_test.vFun.notnone(errmsg='required')('name', None)
  with pytest.raises(ValueError, match='empty'):
    module_under_test.vFun.notempty(errmsg='empty')('name', '')

def test_vfun_length_validators_cover_success_and_failure() -> None:
  assert module_under_test.vFun.haslen(3)('name', 'abc') == 'abc'
  with pytest.raises(ValueError, match='length 2 not equal to 3'):
    module_under_test.vFun.haslen(3)('name', 'ab')

  assert module_under_test.vFun.lenmax(3)('name', 'abc') == 'abc'
  with pytest.raises(ValueError, match='more than max 3'):
    module_under_test.vFun.lenmax(3)('name', 'abcd')

  assert module_under_test.vFun.lenmin(2)('name', 'abc') == 'abc'
  with pytest.raises(ValueError, match='less than min 2'):
    module_under_test.vFun.lenmin(2)('name', 'a')
  assert module_under_test.vFun.lenmin(2, need=False)('name', None) is None

def test_vfun_inrange_current_behaviour_and_optional_none() -> None:
  validator = module_under_test.vFun.inrange(1, 5)
  assert validator('n', 3) == 3
  with pytest.raises(ValueError, match='must be between 1 to 5'):
    validator('n', 7)
  assert module_under_test.vFun.inrange(1, 5, need=False)('n', None) is None

def test_vfun_inlist_allows_and_rejects() -> None:
  validator = module_under_test.vFun.inlist('a', 'b', 'c')
  assert validator('k', 'b') == 'b'
  with pytest.raises(ValueError, match='must be one of'):
    validator('k', 'z')

def test_vfun_inlist_supports_tuple_input_and_inverse() -> None:
  validator = module_under_test.vFun.inlist(('a', 'b'))
  assert validator('k', 'a') == 'a'
  inverse_validator = module_under_test.vFun.inlist('x', 'y', inv=True)
  assert inverse_validator('k', 'z') == 'z'
  with pytest.raises(ValueError, match='may not be one of x,y'):
    inverse_validator('k', 'x')

def test_vfun_islambda_supports_callable_and_optional_none() -> None:
  assert module_under_test.vFun.islambda(lambda value: value > 0)('n', 5) == 5
  assert module_under_test.vFun.islambda(lambda value: value > 0, need=False)('n', None) is None
  with pytest.raises(ValueError, match='must be positive'):
    module_under_test.vFun.islambda(lambda value: value > 0, errmsg='must be positive')('n', -1)
  with pytest.raises(TypeError, match='condition must be callable'):
    module_under_test.vFun.islambda(True)('n', 1)

def test_vfun_regex_inv_true_requires_match() -> None:
  validator = module_under_test.vFun.regex(r'^[A-Z]+$', inv=True)
  assert validator('code', 'ABC') == 'ABC'
  with pytest.raises(ValueError, match='must conform to regex'):
    validator('code', 'Abc')

def test_vfun_regex_default_mode_rejects_matching_values_and_invalid_pattern() -> None:
  validator = module_under_test.vFun.regex(r'^[A-Z]+$')
  assert validator('code', 'Abc') == 'Abc'
  with pytest.raises(ValueError, match='may not conform to regex'):
    validator('code', 'ABC')
  with pytest.raises(ValueError, match='is not a valid regex'):
    module_under_test.vFun.regex('[')

def test_vfun_fileexists(tmp_path) -> None:
  file_path = tmp_path / 'x.txt'
  file_path.write_text('ok', encoding='utf-8')
  validator = module_under_test.vFun.fileexists()
  assert validator('file', str(file_path)) == str(file_path)
  with pytest.raises(ValueError, match='does not exist'):
    validator('file', str(file_path.with_name('missing.txt')))

def test_vfun_file_access_validators_support_optional_none_and_existing_files(tmp_path) -> None:
  file_path = tmp_path / 'x.txt'
  file_path.write_text('ok', encoding='utf-8')

  assert module_under_test.vFun.fileexists(need=False)('file', None) is None
  assert module_under_test.vFun.isfilereadable()('file', str(file_path)) == str(file_path)
  assert module_under_test.vFun.isfilewritable()('file', str(file_path)) == str(file_path)
  assert module_under_test.vFun.isfileexecutable(need=False)('file', None) is None

def test_vfun_file_access_validators_raise_for_missing_files(tmp_path) -> None:
  missing = str(tmp_path / 'missing.txt')
  with pytest.raises(ValueError, match='missing'):
    module_under_test.vFun.isfilereadable(errmsg='missing')('file', missing)
  with pytest.raises(ValueError, match='missing'):
    module_under_test.vFun.isfilewritable(errmsg='missing')('file', missing)
  with pytest.raises(ValueError, match='missing'):
    module_under_test.vFun.isfileexecutable(errmsg='missing')('file', missing)

Tests: test_catalogue

'''Behavioral unit tests for fluidsolve.catalogue.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring

import inspect
import json
import pytest
import fluidsolve.catalogue as module_under_test

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['Catalogue'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

@pytest.mark.parametrize('name', ['Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

def test_catalogue_loads_builtin_libraries() -> None:
  cat = module_under_test.Catalogue(load=True)
  libs = cat.findLibraries()
  assert len(libs) > 0
  assert 'PUMP:C:APV' in libs
  assert 'PIPE:NW' in libs

def test_find_libraries_matchcase_false() -> None:
  cat = module_under_test.Catalogue(load=True)
  libs = cat.findLibraries('apv', matchcase=False)
  assert 'PUMP:C:APV' in libs

def test_find_libraries_with_expression() -> None:
  cat = module_under_test.Catalogue(load=True)
  libs = cat.findLibraries('pump AND centrifugal')
  assert 'PUMP:C:APV' in libs

def test_search_in_library_with_numeric_and_string_criteria() -> None:
  cat = module_under_test.Catalogue(load=True)
  records = cat.searchInLibrary(
    'PUMP:C:APV',
    'T = centrifugal AND spec = "W+ 22/20" AND impeller0 = 110 AND speed0 = 2900',
  )
  assert len(records) >= 1
  for rec in records:
    assert rec['T'] == 'centrifugal'
    assert rec['spec'] == 'W+ 22/20'
    assert rec['impeller0'] == 110
    assert rec['speed0'] == 2900

def test_search_in_library_list_input() -> None:
  cat = module_under_test.Catalogue(load=True)
  records = cat.searchInLibrary(['PIPE:NW'], 'OD < 20')
  dns = {rec['DN'] for rec in records}
  assert 'DN10' in dns
  assert 'DN15' in dns

def test_parse_expression_builds_tree_for_and_or() -> None:
  cat = module_under_test.Catalogue(load=False)
  parsed = cat._parseExpression(['A', 'AND', '(', 'B', 'OR', 'C', ')'])  # pylint: disable=protected-access
  assert 'AND' in parsed
  assert parsed['AND'][0] == 'A'
  assert 'OR' in parsed['AND'][1]

def test_eval_record_expression_supports_not() -> None:
  cat = module_under_test.Catalogue(load=False)
  expr = {'NOT': 'OD < 10'}
  rec = {'OD': 13.0}
  assert cat._evalRecExpression(expr, rec) is True  # pylint: disable=protected-access

def test_load_data_from_custom_path_only(tmp_path) -> None:
  data = {
    'library': {
      'name': 'TEST:LIB',
      'keywords': ['demo', 'custom'],
      'norm': [],
    },
    'keys': ['k', 'v'],
    'records': [{'k': 'x', 'v': 1}],
  }
  file_path = tmp_path / 'test_lib.json'
  file_path.write_text(json.dumps(data), encoding='utf-8')
  cat = module_under_test.Catalogue(path=str(tmp_path), load=False)
  cat.loadAllData(buildin=False)
  libs = cat.findLibraries()
  assert libs == ['TEST:LIB']

def test_catalogue_init_normalizes_path_string_to_single_item_list(tmp_path) -> None:
  cat = module_under_test.Catalogue(path=str(tmp_path), load=False)
  assert cat._path == [str(tmp_path)]  # pylint: disable=protected-access

def test_load_all_data_reports_invalid_json_and_skips_file(tmp_path, capsys) -> None:
  valid_data = {
    'library': {'name': 'VALID:LIB', 'keywords': ['valid'], 'norm': []},
    'keys': ['name'],
    'records': [{'name': 'demo'}],
  }
  (tmp_path / 'valid.json').write_text(json.dumps(valid_data), encoding='utf-8')
  (tmp_path / 'broken.json').write_text('{not valid json', encoding='utf-8')
  cat = module_under_test.Catalogue(path=str(tmp_path), load=False)
  cat.loadAllData(buildin=False)
  captured = capsys.readouterr()
  assert 'Error decoding JSON from file' in captured.out
  assert cat.findLibraries() == ['VALID:LIB']

def test_find_libraries_empty_criteria_returns_all_loaded_keys() -> None:
  cat = module_under_test.Catalogue(load=False)
  cat._d = {  # pylint: disable=protected-access
    'LIB:A': {'library': {'name': 'LIB:A', 'keywords': ['pump'], 'norm': []}, 'records': []},
    'LIB:B': {'library': {'name': 'LIB:B', 'keywords': ['valve'], 'norm': []}, 'records': []},
  }
  assert cat.findLibraries() == ['LIB:A', 'LIB:B']

def test_find_libraries_supports_not_and_wildcards() -> None:
  cat = module_under_test.Catalogue(load=False)
  cat._d = {  # pylint: disable=protected-access
    'PUMP:C:APV': {'library': {'name': 'PUMP:C:APV', 'keywords': ['pump', 'centrifugal', 'APV'], 'norm': []}, 'records': []},
    'VALVE:C:GEN': {'library': {'name': 'VALVE:C:GEN', 'keywords': ['valve', 'control'], 'norm': []}, 'records': []},
  }
  assert cat.findLibraries('pump AND A*') == ['PUMP:C:APV']
  assert cat.findLibraries('NOT valve') == ['PUMP:C:APV']

def test_search_in_library_respects_matchcase_for_record_strings() -> None:
  cat = module_under_test.Catalogue(load=False)
  cat._d = {  # pylint: disable=protected-access
    'TEST:LIB': {
      'library': {'name': 'TEST:LIB', 'keywords': ['demo'], 'norm': []},
      'records': [
        {'kind': 'Pump', 'dn': 20},
        {'kind': 'Valve', 'dn': 25},
      ],
    },
  }
  assert cat.searchInLibrary('TEST:LIB', 'kind = pump', matchcase=False) == [{'kind': 'Pump', 'dn': 20}]
  assert not cat.searchInLibrary('TEST:LIB', 'kind = pump', matchcase=True)

def test_parse_expression_keeps_quoted_values_with_spaces_together() -> None:
  cat = module_under_test.Catalogue(load=False)
  parsed = cat._parseExpression(['spec', '=', '"W+', '22/20"', 'AND', 'speed0', '=', '2900'])  # pylint: disable=protected-access
  assert parsed == {'AND': ['spec = "W+ 22/20"', 'speed0 = 2900']}

def test_parse_expression_unclosed_quote_raises_value_error() -> None:
  cat = module_under_test.Catalogue(load=False)
  with pytest.raises(ValueError, match='Unclosed quoted value'):
    cat._parseExpression(['spec', '=', '"W+'])  # pylint: disable=protected-access

def test_eval_library_expression_raises_for_invalid_expression_shape() -> None:
  cat = module_under_test.Catalogue(load=False)
  with pytest.raises(ValueError, match='Invalid expression format'):
    cat._evalLibExpression({'XOR': ['pump', 'valve']}, ['pump'])  # pylint: disable=protected-access

def test_eval_record_expression_supports_comparisons_and_missing_fields() -> None:
  cat = module_under_test.Catalogue(load=False)
  rec = {'dn': 25, 'kind': 'Valve'}
  assert cat._evalRecExpression('dn >= 20', rec) is True  # pylint: disable=protected-access
  assert cat._evalRecExpression('kind != Pump', rec) is True  # pylint: disable=protected-access
  assert cat._evalRecExpression('missing = x', rec) is False  # pylint: disable=protected-access

def test_eval_record_expression_raises_for_invalid_inputs() -> None:
  cat = module_under_test.Catalogue(load=False)
  with pytest.raises(ValueError, match='Invalid atomic criterion'):
    cat._evalRecExpression('invalid criterion', {'dn': 25})  # pylint: disable=protected-access
  with pytest.raises(ValueError, match='Invalid expression format'):
    cat._evalRecExpression({'XOR': ['dn > 10', 'dn < 30']}, {'dn': 25})  # pylint: disable=protected-access

Tests: test_comp_base

'''Auto-generated tests for fluidsolve.comp_base.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring,missing-class-docstring

import inspect
import types
import pytest
import fluidsolve.comp_base as module_under_test

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['Comp_Base', 'Comp_Dummy', 'Comp_Reverse'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

def test_public_functions_are_callable() -> None:
  public_function_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isfunction)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]
  for name in public_function_names:
    obj = getattr(module_under_test, name)
    assert callable(obj)

@pytest.mark.parametrize('name', ['NO_DIAMETER', 'NO_LENGTH', 'NO_MEDIUM', 'Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

def test_comp_base_defaults_and_properties() -> None:
  comp = module_under_test.Comp_Base(name='base', state=3)
  assert comp.name == 'base'
  assert comp.group == 'Base'
  assert comp.part == 'Base'
  assert comp.nports == 2
  assert comp.ports == [[1, 2]]
  assert comp.state == 3
  assert comp.sign == -1.0
  assert comp.e == module_under_test.flsme.CTE_E_RVS.to(module_under_test.u.um)
  assert isinstance(comp.medium, module_under_test.flsme.Medium)

def test_comp_base_medium_and_roughness_setters() -> None:
  comp = module_under_test.Comp_Base()
  medium = module_under_test.flsme.Medium(prd='water')
  comp.medium = medium
  assert comp.medium is medium
  comp.medium = 'water'
  assert isinstance(comp.medium, module_under_test.flsme.Medium)
  assert comp.medium.name == 'water'
  comp.e = 15
  roughness = comp.e
  assert isinstance(roughness, module_under_test.Quantity)
  assert getattr(roughness, 'magnitude') == 15
  assert getattr(roughness, 'units') == module_under_test.u.um

def test_comp_base_medium_setter_rejects_invalid_type() -> None:
  comp = module_under_test.Comp_Base()
  with pytest.raises(TypeError, match='Medium must be a string or an instance of Medium'):
    comp.medium = 123  # type: ignore[assignment]

def test_comp_base_state_setter_updates_state() -> None:
  comp = module_under_test.Comp_Base()
  comp.state = 2.5
  assert comp.state == 2.5

def test_comp_base_calc_methods_and_clone() -> None:
  comp = module_under_test.Comp_Base(name='base')

  assert comp.calcH(5).to(module_under_test.u.m).magnitude == 0.0
  assert comp.calcP(5).to(module_under_test.u.bar).magnitude == pytest.approx(0.0)

  clone = comp.clone()
  assert isinstance(clone, module_under_test.Comp_Base)
  assert clone is not comp
  assert clone.name == comp.name
  assert clone.medium is not comp.medium
  assert clone.medium.name == comp.medium.name

def test_comp_base_calcq_uses_root_result(monkeypatch) -> None:
  comp = module_under_test.Comp_Base()

  def fake_root(func=None, x0=None, method=None):
    assert x0 == 200
    assert method in ('hybr', 'lm', 'df-sane')
    assert func(12) == pytest.approx(0.0)
    return types.SimpleNamespace(success=True, x=[12], message='ok', status=1)

  def fake_calcH(flow, sense=1, pin=1, pout=2):
    assert sense == 1
    assert pin == 1
    assert pout == 2
    return flow.to(module_under_test.u.m**3 / module_under_test.u.h).magnitude * module_under_test.u.m / 12

  monkeypatch.setattr(module_under_test, 'root', fake_root)
  monkeypatch.setattr(comp, 'calcH', fake_calcH)

  result = comp.calcQ(1 * module_under_test.u.m, guess=200)
  assert result.magnitude == 12
  assert result.units == module_under_test.u.m**3 / module_under_test.u.h

def test_comp_base_string_representation_contains_metadata() -> None:
  comp = module_under_test.Comp_Base(name='base', state=2)

  text = str(comp)
  assert 'Component: "base" [Base]' == text

def test_comp_base_format_representation_supports_detail() -> None:
  comp = module_under_test.Comp_Base(name='base', state=2)

  text = f'{comp:1}'
  assert 'Component: "base" [Base:Base]' in text
  assert 'state: 2' in text
  assert 'sign: -1' in text

def test_comp_dummy_initializes_as_resistance() -> None:
  comp = module_under_test.Comp_Dummy(name='dummy')

  assert comp.group == 'Base'
  assert comp.part == 'Dummy'
  assert comp.name == 'dummy'
  assert isinstance(comp.medium, module_under_test.flsme.Medium)

def test_comp_reverse_delegates_calc_methods_and_attributes() -> None:
  class ReverseableComp(module_under_test.Comp_Base):
    def __init__(self):
      super().__init__(name='wrapped')

    def calcK(self, Q, sense=1, pin=1, pout=2):
      return (Q, sense, pin, pout)

    def calcH(self, Q, sense=1, pin=1, pout=2):
      return sense * 3 * module_under_test.u.m

  wrapped = ReverseableComp()
  comp = module_under_test.Comp_Reverse(name='rev', reverse=wrapped)

  assert comp.calcK(5, sense=1, pin=2, pout=3) == (5, -1, 2, 3)
  assert comp.calcH(5, sense=1, pin=2, pout=3) == -3 * module_under_test.u.m
  assert comp.name == 'rev'
  assert comp.part == 'Reverse'
  assert 'reverse:' in str(comp)
  assert '"wrapped"  [Base]' in str(comp)
  assert ' reverse' in f'{comp:1}'
  assert 'Component: "wrapped" [Base:Base]' in f'{comp:1}'

def test_comp_reverse_raises_when_wrapped_component_has_no_calck() -> None:
  class HeadOnlyComp(module_under_test.Comp_Base):
    def calcH(self, Q, sense=1, pin=1, pout=2):
      return 0 * module_under_test.u.m

  wrapped = HeadOnlyComp(name='wrapped')
  comp = module_under_test.Comp_Reverse(reverse=wrapped)

  with pytest.raises(AttributeError, match='has no calcK'):
    comp.calcK(5)

Tests: test_comp_pump

'''Auto-generated tests for fluidsolve.comp_pump.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring

import inspect
import pytest
import fluidsolve.comp_pump as module_under_test

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['Comp_Pump', 'Comp_PumpCentrifugal', 'Comp_PumpParallel', 'Comp_PumpSerial'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

def test_public_functions_are_callable() -> None:
  public_function_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isfunction)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]

  for name in public_function_names:
    obj = getattr(module_under_test, name)
    assert callable(obj)

@pytest.mark.parametrize('name', ['N_CURVE_POINTS', 'Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

def test_comp_pump_requires_curve_data_by_default() -> None:
  with pytest.raises(ValueError, match='No pump data'):
    module_under_test.Comp_Pump(speed0=2900)

def test_comp_pump_initializes_curve_properties_and_metadata() -> None:
  pump = module_under_test.Comp_Pump(
    vendor='demo',
    spec='model',
    din=50,
    dout=40,
    speed0=2900,
    dataQH=[0, 12, 10, 6, 20, 0],
  )

  assert pump.vendor == 'demo'
  assert pump.spec == 'model'
  assert pump.din == 50 * module_under_test.u.mm
  assert pump.dout == 40 * module_under_test.u.mm
  assert pump.speed0 == 2900 * module_under_test.u.rpm
  assert pump.speed == 2900 * module_under_test.u.rpm
  assert pump.Qb == 0 * module_under_test.u.m**3 / module_under_test.u.h
  assert pump.Qe == 20 * module_under_test.u.m**3 / module_under_test.u.h
  assert pump.Qc == 0 * module_under_test.u.m**3 / module_under_test.u.h
  assert pump.Hb == 0 * module_under_test.u.m
  assert pump.He == 12 * module_under_test.u.m

def test_comp_pump_calcH_and_calcQ_cover_forward_reverse_and_clamping() -> None:
  pump = module_under_test.Comp_Pump(speed0=2900, dataQH=[0, 12, 10, 6, 20, 0])

  assert pump.calcH(5).to(module_under_test.u.m).magnitude == pytest.approx(9.0)
  assert pump.calcH(5, sense=-1).to(module_under_test.u.m).magnitude == 0.0
  assert pump.calcH(-5, sense=-1).to(module_under_test.u.m).magnitude == pytest.approx(9.0)
  assert pump.calcH(25).to(module_under_test.u.m).magnitude == 0.0

  assert pump.calcQ(6 * module_under_test.u.m).to(module_under_test.u.m**3 / module_under_test.u.h).magnitude == pytest.approx(10.0)
  assert pump.calcQ(-1 * module_under_test.u.m).to(module_under_test.u.m**3 / module_under_test.u.h).magnitude == pytest.approx(21.666666666666668)

def test_comp_pump_speed_setter_accepts_scalar_and_updates_quantity() -> None:
  pump = module_under_test.Comp_Pump(speed0=2900, dataQH=[0, 12, 10, 6, 20, 0])

  pump.speed = 1450
  assert pump.speed == 1450 * module_under_test.u.rpm
  assert pump.calcH(5).to(module_under_test.u.m).magnitude == pytest.approx(9.0)

def test_comp_pump_to_string_includes_metadata() -> None:
  pump = module_under_test.Comp_Pump(vendor='demo', spec='model', speed0=2900, dataQH=[0, 12, 10, 6, 20, 0])

  text = pump.toString()
  assert 'Pump: demo: model' in text
  assert 'speed0:2900 revolutions_per_minute' in text

def test_comp_pump_centrifugal_scales_curve_with_speed_and_impeller() -> None:
  pump = module_under_test.Comp_PumpCentrifugal(
    speed0=2900,
    speed=1450,
    impeller0=100,
    impeller=50,
    dataQH=[0, 12, 10, 6, 20, 0],
  )

  assert pump.impeller0 == 100 * module_under_test.u.mm
  assert pump.impeller == 50 * module_under_test.u.mm
  assert pump.Qe.to(module_under_test.u.m**3 / module_under_test.u.h).magnitude == pytest.approx(2.5)
  assert pump.calcH(2.5).to(module_under_test.u.m).magnitude == pytest.approx(0.375)

def test_comp_pump_centrifugal_trims_negative_head_data() -> None:
  pump = module_under_test.Comp_PumpCentrifugal(
    speed0=2900,
    impeller0=100,
    dataQH=[0, 12, 10, 4, 20, -1],
  )

  assert pump.Qe.to(module_under_test.u.m**3 / module_under_test.u.h).magnitude == pytest.approx(10.0)
  assert pump.calcH(20).to(module_under_test.u.m).magnitude == 0.0

def test_comp_pump_serial_combines_pump_heads() -> None:
  pump_a = module_under_test.Comp_Pump(speed0=2900, dataQH=[0, 10, 10, 5, 20, 0])
  pump_b = module_under_test.Comp_Pump(speed0=2900, dataQH=[0, 8, 10, 4, 20, 0])
  serial = module_under_test.Comp_PumpSerial(pumps=[pump_a, pump_b])

  assert serial.Qb == 0 * module_under_test.u.m**3 / module_under_test.u.h
  assert serial.Qe == 20 * module_under_test.u.m**3 / module_under_test.u.h
  assert serial.calcH(10).to(module_under_test.u.m).magnitude == pytest.approx(9.0)
  assert serial.calcH(10, sense=-1).to(module_under_test.u.m).magnitude == 0.0
  assert serial.calcQ(9 * module_under_test.u.m).to(module_under_test.u.m**3 / module_under_test.u.h).magnitude == pytest.approx(10.0)

def test_comp_pump_serial_requires_at_least_one_pump() -> None:
  with pytest.raises(ValueError, match='less than min 1'):
    module_under_test.Comp_PumpSerial(pumps=[])

def test_comp_pump_parallel_combines_flows() -> None:
  pump_a = module_under_test.Comp_Pump(speed0=2900, dataQH=[0, 10, 10, 5, 20, 0])
  pump_b = module_under_test.Comp_Pump(speed0=2900, dataQH=[0, 8, 10, 4, 20, 0])
  parallel = module_under_test.Comp_PumpParallel(pumps=[pump_a, pump_b])

  assert parallel.Qb.to(module_under_test.u.m**3 / module_under_test.u.h).magnitude > 0
  assert parallel.Qe.to(module_under_test.u.m**3 / module_under_test.u.h).magnitude > parallel.Qb.to(module_under_test.u.m**3 / module_under_test.u.h).magnitude
  assert parallel.calcQ(5 * module_under_test.u.m).to(module_under_test.u.m**3 / module_under_test.u.h).magnitude == pytest.approx(17.5)
  assert parallel.calcH(17.5).to(module_under_test.u.m).magnitude == pytest.approx(5.0)

def test_serial_and_parallel_to_string_include_labels() -> None:
  pump = module_under_test.Comp_Pump(speed0=2900, dataQH=[0, 10, 10, 5, 20, 0])

  serial = module_under_test.Comp_PumpSerial(pumps=[pump])
  parallel = module_under_test.Comp_PumpParallel(pumps=[pump])

  assert 'Serial pumps:' in serial.toString()
  assert 'Parallel pumps:' in parallel.toString()

Tests: test_comp_resist

'''Auto-generated tests for fluidsolve.comp_resist.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-class-docstring,missing-function-docstring

import inspect
from types import SimpleNamespace
import pytest
import numpy as np
import fluidsolve.comp_resist as module_under_test

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['C_EntranceBeveled', 'Comp_Appendage', 'Comp_Bend', 'Comp_BendLong', 'Comp_ConicalReduction', 'Comp_Entrance', 'Comp_Hstatic',
                                  'Comp_PHE', 'Comp_Parallel', 'Comp_Parallel2', 'Comp_Serial', 'Comp_SharpReduction', 'Comp_Tube'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

def test_public_functions_are_callable() -> None:
  public_function_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isfunction)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]

  for name in public_function_names:
    obj = getattr(module_under_test, name)
    assert callable(obj)

@pytest.mark.parametrize('name', ['Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

def test_comp_hstatic_properties_calcH_and_to_string() -> None:
  comp = module_under_test.Comp_Hstatic(name='hs', Hs_pos=5, Hs_neg=2)

  assert comp.Hs == 3 * module_under_test.u.m
  assert comp.calcH(1, sense=1, pin=1, pout=2) == 3 * module_under_test.u.m
  assert comp.calcH(1, sense=1, pin=2, pout=1) == -3 * module_under_test.u.m

  comp.Hs = 4
  assert comp.Hs == 4 * module_under_test.u.m
  assert 'Hs: 4.00 m' in comp.toString()

def test_comp_appendage_calcH_uses_loss_coefficient_and_to_string() -> None:
  class FixedKAppendage(module_under_test.Comp_Appendage):
    def __init__(self) -> None:
      super().__init__(name='app', medium='water')
      self._D = 50 * module_under_test.u.mm
      self._L = 2 * module_under_test.u.m

    def calcK(self, Q, sense=1, pin=1, pout=2):
      return 4.0

  comp = FixedKAppendage()
  head = comp.calcH(10)

  expected = module_under_test.flsu.KtoH(4.0, module_under_test.flsu.Qtov(10 * module_under_test.u.m**3 / module_under_test.u.h, comp._D)) * comp.sign  # pylint: disable=protected-access
  assert head.to(module_under_test.u.m).magnitude == pytest.approx(expected.to(module_under_test.u.m).magnitude)
  assert 'L: 2.00 m' in comp.toString()
  assert 'D: 50.00 mm' in comp.toString()

def test_comp_tube_properties_and_calcH_with_static_head(monkeypatch) -> None:
  tube = module_under_test.Comp_Tube(L=10, D=50, Hs_pos=2)

  monkeypatch.setattr(tube, 'calcK', lambda *args, **kwargs: 0.0)
  assert tube.calcH(0).to(module_under_test.u.m).magnitude == pytest.approx(2.0)

  tube.L = 12
  tube.D = 60
  tube.Hs = 1
  assert tube.L == 12 * module_under_test.u.m
  assert tube.D == 60 * module_under_test.u.mm
  assert tube.Hs == 1 * module_under_test.u.m

def test_comp_bend_and_bendlong_delegate_to_fluids_helpers(monkeypatch) -> None:
  monkeypatch.setattr(module_under_test.fu, 'Reynolds', lambda **kwargs: 123.0)
  monkeypatch.setattr(module_under_test.fu, 'friction_factor', lambda *args, **kwargs: 0.02)
  monkeypatch.setattr(module_under_test.fu, 'bend_rounded', lambda **kwargs: 7.5)
  monkeypatch.setattr(module_under_test.fu, 'bend_miter', lambda *args, **kwargs: 4.5 if 'L_unimpeded' not in kwargs else 5.5)

  bend = module_under_test.Comp_Bend(D=80)
  assert bend.calcK(10, sense=1) == pytest.approx(7.5)

  bend_long = module_under_test.Comp_BendLong(D=80)
  assert bend_long.calcK(10, sense=1) == pytest.approx(4.5)

  bend_long_lu = module_under_test.Comp_BendLong(D=80, Lu=1)
  assert bend_long_lu.calcK(10, sense=1) == pytest.approx(5.5)

def test_comp_entrance_selects_entrance_or_exit_loss(monkeypatch) -> None:
  monkeypatch.setattr(module_under_test.fu, 'entrance_sharp', lambda: 1.25)
  monkeypatch.setattr(module_under_test.fu, 'exit_normal', lambda: 0.75)

  comp = module_under_test.Comp_Entrance(D=50)
  assert comp.calcK(10, sense=1, pin=1, pout=2) == pytest.approx(1.25)
  assert comp.calcK(10, sense=1, pin=2, pout=1) == pytest.approx(0.75)

def test_sharp_and_conical_reduction_validate_and_switch_branches(monkeypatch) -> None:
  with pytest.raises(ValueError, match='must be larger than D2'):
    module_under_test.Comp_SharpReduction(D1=40, D2=50)

  monkeypatch.setattr(module_under_test.fu, 'contraction_sharp', lambda **kwargs: 2.0)
  monkeypatch.setattr(module_under_test.fu, 'diffuser_sharp', lambda **kwargs: 3.0)
  sharp = module_under_test.Comp_SharpReduction(D1=80, D2=40)
  assert sharp.calcK(10, sense=1, pin=1, pout=2) == pytest.approx(2.0)
  assert sharp.calcK(10, sense=1, pin=2, pout=1) == pytest.approx(3.0)

  with pytest.raises(ValueError, match='must be larger than D2'):
    module_under_test.Comp_ConicalReduction(D1=40, D2=50, L=1)

  monkeypatch.setattr(module_under_test.fu, 'Reynolds', lambda **kwargs: 100.0)
  monkeypatch.setattr(module_under_test.fu, 'friction_factor', lambda *args, **kwargs: 0.02)
  monkeypatch.setattr(module_under_test.fu, 'fittings', SimpleNamespace(
    contraction_conical=lambda **kwargs: 4.0,
    diffuser_conical=lambda **kwargs: 5.0,
  ), raising=False)
  conical = module_under_test.Comp_ConicalReduction(D1=80, D2=40, L=1)
  assert conical.calcK(10, sense=1, pin=1, pout=2) == pytest.approx(4.0)
  assert conical.calcK(10, sense=1, pin=2, pout=1) == pytest.approx(5.0)

def test_beveled_entrance_forward_and_reverse_flow(monkeypatch) -> None:
  monkeypatch.setattr(module_under_test.fu, 'entrance_beveled', lambda *args, **kwargs: 6.0)
  with pytest.raises(TypeError, match='argument left'):
    module_under_test.C_EntranceBeveled(D=50, Lb=5, R=45)

def test_comp_serial_combines_components_and_builds_profile() -> None:
  class FixedHead(module_under_test.flsb.Comp_Base):
    def __init__(self, name: str, head: float) -> None:
      super().__init__(name=name)
      self._head = head * module_under_test.u.m

    def calcH(self, Q, sense=1, pin=1, pout=2):
      return self._head * sense

  comp_a = FixedHead('a', 2)
  comp_b = FixedHead('b', 3)
  serial = module_under_test.Comp_Serial(comps=[comp_a, comp_b])

  assert serial.components == [comp_a, comp_b]
  assert serial.getComp(0) is comp_a
  assert serial.calcH(1).to(module_under_test.u.m).magnitude == pytest.approx(5.0)

  profile = serial.calcHprofile(1, sense=1, incr=True)
  assert [point.name for point in profile] == ['0:a', '1:b', 'Tot']
  assert profile[0].H.to(module_under_test.u.m).magnitude == pytest.approx(2.0)
  assert profile[1].H.to(module_under_test.u.m).magnitude == pytest.approx(5.0)

  comp_c = FixedHead('c', 4)
  assert serial.setComp(1, comp_c) is comp_c
  assert serial.addComp(comp_b) is comp_b
  assert 'Sub-Components: (3):' in serial.toString()
  assert 'idx | Comp' in serial.toString()
  assert 'a' in serial.toString()

def test_comp_parallel_validates_guess_and_uses_root_result(monkeypatch) -> None:
  class FixedHead(module_under_test.flsb.Comp_Base):
    def __init__(self, name: str, head: float) -> None:
      super().__init__(name=name)
      self._head = head * module_under_test.u.m

    def calcH(self, Q, sense=1, pin=1, pout=2):
      return self._head

  comp_a = FixedHead('a', 2)
  comp_b = FixedHead('b', 2)
  parallel = module_under_test.Comp_Parallel(comps=[comp_a, comp_b], guess=[1.0])

  parallel.guess = [1.0, 1.0]

  def fake_root(func=None, x0=None, args=None, method=None):
    assert callable(func)
    assert list(x0) == [1.0, 1.0]
    assert args == pytest.approx((2.0,))
    assert method in ('hybr', 'lm', 'df-sane')
    return SimpleNamespace(success=True, x=[0.5, 1.5], message='ok', status=1)

  monkeypatch.setattr(module_under_test, 'root', fake_root)
  head = parallel.calcH(2)
  assert head.to(module_under_test.u.m).magnitude == pytest.approx(2.0)
  assert list(parallel.getQ().magnitude) == pytest.approx([0.5, 1.5])
  assert 'Sub-Components: (2):' in parallel.toString()
  assert 'idx | Comp' in parallel.toString()
  assert parallel.components == [comp_a, comp_b]

def test_comp_parallel2_uses_solver_result_and_reports_failure(monkeypatch) -> None:
  class FixedHead(module_under_test.flsb.Comp_Base):
    def __init__(self, name: str, head: float) -> None:
      super().__init__(name=name)
      self._head = head * module_under_test.u.m

    def calcH(self, Q, sense=1, pin=1, pout=2):
      return self._head

  comp_a = FixedHead('a', 2)
  comp_b = FixedHead('b', 2)
  parallel = module_under_test.Comp_Parallel2(comps=[comp_a, comp_b], guess=1.0)

  def fake_ok(func=None, x0=None, args=None, method=None):
    assert callable(func)
    assert x0 == 1.0
    assert args == pytest.approx((2.0,))
    assert method in ('hybr', 'lm', 'df-sane')
    return SimpleNamespace(success=True, x=np.array([0.75]), message='ok', status=1)

  monkeypatch.setattr(module_under_test, 'root', fake_ok)
  head = parallel.calcH(2)
  assert head.to(module_under_test.u.m).magnitude == pytest.approx(2.0)
  assert parallel.getQ()[0].magnitude == pytest.approx(0.75)
  assert parallel.components == [comp_a, comp_b]

  def fake_fail(func=None, x0=None, args=None, method=None):
    assert callable(func)
    assert x0 == 1.0
    assert args == pytest.approx((2.0,))
    assert method in ('hybr', 'lm', 'df-sane')
    return SimpleNamespace(success=False, x=np.array([0.75]), message='failed', status=4)

  monkeypatch.setattr(module_under_test, 'root', fake_fail)
  with pytest.warns(RuntimeWarning, match='failed|no convergence'):
    parallel.calcH(2)
  assert parallel.getQ()[0].to(module_under_test.u.m**3 / module_under_test.u.h).magnitude == pytest.approx(2.0)
  assert parallel.getQ()[1].to(module_under_test.u.m**3 / module_under_test.u.h).magnitude == pytest.approx(0.0)
  assert 'Sub-Components: (2):' in parallel.toString()
  assert 'idx | Comp' in parallel.toString()

Tests: test_comp_valve

'''Auto-generated tests for fluidsolve.comp_valve.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring

import inspect
import pytest
import fluidsolve.comp_valve as module_under_test

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['Comp_Valve', 'Comp_Valve_01', 'Comp_Valve_3W', 'Comp_Valve_DS', 'Comp_Valve_Kv', 'Comp_Valve_NR'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

def test_public_functions_are_callable() -> None:
  public_function_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isfunction)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]

  for name in public_function_names:
    obj = getattr(module_under_test, name)
    assert callable(obj)

@pytest.mark.parametrize('name', ['Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

def test_comp_valve_base_properties_and_to_string() -> None:
  valve = module_under_test.Comp_Valve(name='valve', D=50, state=1)

  assert valve.group == 'Resistance'
  assert valve.part == 'Valve'
  assert valve.state == 1
  assert valve.calcK(1, sense=1) == 0.0
  assert 'State:1.00' in valve.toString()
  assert 'D:50.00 mm' in valve.toString()

def test_comp_valve_base_calcH_uses_loss_conversion(monkeypatch) -> None:
  valve = module_under_test.Comp_Valve(D=50)

  monkeypatch.setattr(module_under_test.flsu, 'Qtov', lambda flow, diameter: 3.0)
  monkeypatch.setattr(module_under_test.flsu, 'KtoH', lambda loss, velocity: (loss + velocity) * module_under_test.u.m)
  monkeypatch.setattr(valve, 'calcK', lambda *args, **kwargs: 2.0)

  assert valve.calcH(10).magnitude == pytest.approx(-5.0)

def test_comp_valve_nr_allows_only_forward_flow() -> None:
  valve = module_under_test.Comp_Valve_NR(D=50)

  assert valve.calcK(1, sense=1, pin=1, pout=2) == 0.0
  assert valve.calcK(1, sense=1, pin=2, pout=1) == 1e6
  assert valve.calcK(1, sense=-1, pin=1, pout=2) == 1e6

def test_comp_valve_01_switches_between_open_and_closed() -> None:
  valve = module_under_test.Comp_Valve_01(D=50, state=0)
  assert valve.calcK(1, sense=1) == 1e6

  valve.state = 1
  assert valve.calcK(1, sense=1) == 0.0

def test_comp_valve_kv_properties_setters_and_calcK() -> None:
  valve = module_under_test.Comp_Valve_Kv(D=50, Kvs=25, R=4, state=0.5)

  assert valve.Kvs == 25
  assert valve.R == 4
  assert valve.connections() == [(1, 2)]
  assert valve.connections(state=0.0) == [(1, 2)]
  assert valve.connections(state=0.73) == [(1, 2)]
  expected_kv_half = 25.0 * (4.0 ** 0.5 - 1.0) / 3.0
  assert valve.calcK(1, sense=1) == pytest.approx(module_under_test.flsu.KvtoK(expected_kv_half, 50 * module_under_test.u.mm))

  valve.Kvs = 30
  valve.R = 9
  valve.state = 1.0
  assert valve.Kvs == 30
  assert valve.R == 9
  assert valve.calcK(1, sense=1) == pytest.approx(module_under_test.flsu.KvtoK(30.0, 50 * module_under_test.u.mm))

  valve.state = 0.0
  assert valve.calcK(1, sense=1) == 1e6

  valve.state = 0.01
  k_001 = valve.calcK(1, sense=1)
  valve.state = 0.02
  k_002 = valve.calcK(1, sense=1)

  assert k_001 <= 1e6
  assert k_001 > k_002

def test_comp_valve_3w_connections_and_calcK_errors() -> None:
  valve = module_under_test.Comp_Valve_3W(D=50, state=1)

  assert valve.connections() == [(1, 2)]
  assert valve.connections(state=2) == [(1, 3)]
  assert valve.calcK(1, pin=1, pout=2) == pytest.approx(0.7)
  assert valve.calcK(1, pin=2, pout=1) == pytest.approx(0.7)
  assert valve.calcK(1, pin=2, pout=3) == 1e6

  valve.state = 3
  with pytest.raises(ValueError, match='Invalid state for 3-way valve'):
    valve.calcK(1, pin=1, pout=2)

  valve.state = 1
  with pytest.raises(ValueError, match='Invalid ports for 3-way valve'):
    valve.calcK(1, pin=0, pout=2)
  with pytest.raises(ValueError, match='pin and pout must be different'):
    valve.calcK(1, pin=1, pout=1)

def test_comp_valve_ds_connections_and_calcK_errors() -> None:
  valve = module_under_test.Comp_Valve_DS(D=50, state=1)

  assert valve.connections() == [(1, 2), (3, 4)]
  assert valve.connections(state=1) == [(1, 2), (3, 4)]
  assert valve.connections(state=2) == [(1, 2), (1, 3), (3, 4)]
  assert valve.calcK(1, pin=1, pout=2) == pytest.approx(0.7)
  assert valve.calcK(1, pin=2, pout=4) == 1e6

  valve.state = 2
  assert valve.calcK(1, pin=1, pout=3) == pytest.approx(0.7)
  assert valve.calcK(1, pin=2, pout=4) == pytest.approx(0.7)

  valve.state = 9
  with pytest.raises(ValueError, match='Invalid state for 3-way valve'):
    valve.calcK(1, pin=1, pout=2)

  valve.state = 1
  with pytest.raises(ValueError, match='Invalid ports for 3-way valve'):
    valve.calcK(1, pin=5, pout=2)
  with pytest.raises(ValueError, match='pin and pout must be different'):
    valve.calcK(1, pin=1, pout=1)

Tests: test_core

'''Behavioral unit tests for fluidsolve.core.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring,protected-access

import inspect
import pytest
import fluidsolve.core as module_under_test

def test_module_importable() -> None:
  assert module_under_test is not None

def test_public_classes_exist() -> None:
  public_class_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isclass)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]

  for name in public_class_names:
    obj = getattr(module_under_test, name)
    assert inspect.isclass(obj)

@pytest.mark.parametrize(
  'name',
  [
    'getComp',
    'getDefaultMaterial',
    'getDefaultMedium',
    'getNetwork',
    'getPath',
    'getWpt',
    'initFluidsolve',
    'registerAllComps',
    'registerComp',
    'registerComps',
    'setDefaultMaterial',
    'setDefaultMedium',
  ],
)
def test_public_functions_are_callable(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert callable(obj)

@pytest.mark.parametrize('name', ['Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

def test_init_fluidsolve_applies_prefixes_and_default_objects() -> None:
  material = module_under_test.flsma.Material(name='steel', rho=800.0, k=2.0, e=5.0)
  medium = module_under_test.flsme.Medium(prd='water')

  module_under_test.initFluidsolve(
    prefix_comp='X',
    prefix_wpt='Y',
    default_material=material,
    default_medium=medium,
  )

  assert module_under_test._prefix_comp == 'X'
  assert module_under_test._prefix_wpt == 'Y'
  assert module_under_test.getDefaultMaterial() is material
  assert module_under_test.getDefaultMedium() is medium

def test_init_fluidsolve_converts_default_names_to_objects() -> None:
  module_under_test.initFluidsolve(default_material='rvs', default_medium='water')

  assert isinstance(module_under_test.getDefaultMaterial(), module_under_test.flsma.Material)
  assert isinstance(module_under_test.getDefaultMedium(), module_under_test.flsme.Medium)

def test_register_comp_rejects_duplicate_by_default(monkeypatch) -> None:
  monkeypatch.setattr(module_under_test, '_comps', {'Demo': object()})

  with pytest.raises(ValueError, match='already registered'):
    module_under_test.registerComp('Demo', object())

def test_register_comp_returns_false_when_duplicate_and_raiseerror_false(monkeypatch) -> None:
  monkeypatch.setattr(module_under_test, '_comps', {'Demo': object()})

  assert module_under_test.registerComp('Demo', object(), raiseerror=False) is False

def test_register_comp_adds_new_entry(monkeypatch) -> None:
  registry = {}
  monkeypatch.setattr(module_under_test, '_comps', registry)
  marker = object()

  assert module_under_test.registerComp('Demo', marker) is True
  assert registry['Demo'] is marker

def test_register_comps_returns_false_if_any_registration_fails(monkeypatch) -> None:
  calls = []

  def fake_register(name: str, value: object, raiseerror: bool=True) -> bool:
    calls.append((name, value, raiseerror))
    return name != 'Bad'

  monkeypatch.setattr(module_under_test, 'registerComp', fake_register)

  result = module_under_test.registerComps({'Good': 1, 'Bad': 2}, raiseerror=False)

  assert result is False
  assert calls == [('Good', 1, False), ('Bad', 2, False)]

def test_register_all_comps_returns_false_if_any_group_fails(monkeypatch) -> None:
  results = iter([True, False, True, True])
  calls = []

  def fake_register_comps(comps: dict, raiseerror: bool=True) -> bool:
    calls.append((set(comps), raiseerror))
    return next(results)

  monkeypatch.setattr(module_under_test, 'registerComps', fake_register_comps)

  assert module_under_test.registerAllComps() is False
  assert len(calls) == 4
  assert {'Dummy', 'Reverse'} == calls[0][0]
  assert 'Hstatic' in calls[1][0]
  assert 'Pump' in calls[2][0]
  assert 'Valve_NR' in calls[3][0]

def test_default_setters_replace_defaults() -> None:
  material = module_under_test.flsma.Material(name='custom', rho=900.0, k=3.0, e=6.0)
  medium = module_under_test.flsme.Medium(prd='water')

  module_under_test.setDefaultMaterial(material)
  module_under_test.setDefaultMedium(medium)

  assert module_under_test.getDefaultMaterial() is material
  assert module_under_test.getDefaultMedium() is medium

def test_get_comp_builds_instance_with_defaults(monkeypatch) -> None:
  class DummyComp:
    def __init__(self, **kwargs):
      self.kwargs = kwargs

  medium = module_under_test.flsme.Medium(prd='water')
  material = module_under_test.flsma.Material(name='custom', rho=900.0, k=2.0, e=4.0)
  monkeypatch.setattr(module_under_test, '_comps', {'Demo': DummyComp})
  monkeypatch.setattr(module_under_test, '_default_medium', medium)
  monkeypatch.setattr(module_under_test, '_default_material', material)
  monkeypatch.setattr(module_under_test, '_comp_index', 0)
  monkeypatch.setattr(module_under_test, '_prefix_comp', 'C')

  comp = module_under_test.getComp(comp='Demo', answer=42)

  assert isinstance(comp, DummyComp)
  assert comp.kwargs['name'] == 'CA'
  assert comp.kwargs['medium'] is medium
  assert comp.kwargs['e'] == material.e
  assert comp.kwargs['answer'] == 42

def test_get_comp_uses_explicit_values_and_rejects_unknown_type(monkeypatch) -> None:
  class DummyComp:
    def __init__(self, **kwargs):
      self.kwargs = kwargs

  medium = module_under_test.flsme.Medium(prd='water')
  monkeypatch.setattr(module_under_test, '_comps', {'Demo': DummyComp})

  comp = module_under_test.getComp(comp='Demo', name='P1', medium=medium, e=3, state=1)

  assert comp.kwargs == {'name': 'P1', 'medium': medium, 'e': 3, 'state': 1}

  with pytest.raises(ValueError, match='Component type "Missing" is not defined'):
    module_under_test.getComp(comp='Missing')

def test_get_wpt_builds_instance_with_generated_or_explicit_name(monkeypatch) -> None:
  class DummyWpt:
    def __init__(self, **kwargs):
      self.kwargs = kwargs

  monkeypatch.setattr(module_under_test, '_wpts', {'x': DummyWpt})
  monkeypatch.setattr(module_under_test, '_wpt_index', 0)
  monkeypatch.setattr(module_under_test, '_prefix_wpt', 'Wp')

  auto = module_under_test.getWpt(wpt='x', pressure=1)
  named = module_under_test.getWpt(wpt='x', name='Node1', pressure=2)

  assert auto.kwargs == {'name': 'Wp0', 'pressure': 1}
  assert named.kwargs == {'name': 'Node1', 'pressure': 2}

  with pytest.raises(ValueError, match='Workingpoint type "missing" is not defined'):
    module_under_test.getWpt(wpt='missing')

def test_get_path_and_network_delegate_to_target_classes(monkeypatch) -> None:
  class DummyPath:
    def __init__(self, **kwargs):
      self.kwargs = kwargs

  class DummyNetwork:
    def __init__(self, **kwargs):
      self.kwargs = kwargs

  monkeypatch.setattr(module_under_test.flspath, 'Path', DummyPath)
  monkeypatch.setattr(module_under_test.flsnet, 'Network', DummyNetwork)

  path = module_under_test.getPath(name='P', comps=[1, 2])
  network = module_under_test.getNetwork(name='N', components=[])
  path_kwargs = getattr(path, 'kwargs')
  network_kwargs = getattr(network, 'kwargs')

  assert isinstance(path, DummyPath)
  assert isinstance(network, DummyNetwork)
  assert path_kwargs == {'name': 'P', 'comps': [1, 2]}
  assert network_kwargs == {'name': 'N', 'components': []}

def test_generated_names_follow_current_sequence_rules(monkeypatch) -> None:
  monkeypatch.setattr(module_under_test, '_comp_index', 0)
  monkeypatch.setattr(module_under_test, '_wpt_index', 0)
  monkeypatch.setattr(module_under_test, '_prefix_comp', 'C')
  monkeypatch.setattr(module_under_test, '_prefix_wpt', 'Wp')

  comp_names = [module_under_test._getCompName() for _ in range(28)]
  wpt_names = [module_under_test._getWptName() for _ in range(3)]

  assert comp_names[:4] == ['CA', 'CB', 'CC', 'CD']
  assert comp_names[25:] == ['CZ', 'CAA', 'CAB']
  assert wpt_names == ['Wp0', 'Wp1', 'Wp2']

Tests: test_material

'''Auto-generated tests for fluidsolve.material.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring

import inspect
import pytest
import fluidsolve.material as module_under_test

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['Material'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

def test_public_functions_are_callable() -> None:
  public_function_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isfunction)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]

  for name in public_function_names:
    obj = getattr(module_under_test, name)
    assert callable(obj)

@pytest.mark.parametrize('name', ['CTE_E_RVS', 'CTE_G', 'CTE_K', 'CTE_NT', 'CTE_RHO', 'Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

def test_material_defaults_and_public_properties() -> None:
  material = module_under_test.Material()
  temperature = material.T

  assert material.name == 'mat'
  assert getattr(temperature, 'to')(module_under_test.u.degC).magnitude == pytest.approx(20.0)
  assert material.rho == module_under_test.CTE_RHO
  assert material.k == module_under_test.CTE_K
  assert material.e == module_under_test.CTE_E_RVS
  assert material.cmat is None

def test_material_init_accepts_custom_values_and_units() -> None:
  material = module_under_test.Material(
    mat='steel',
    name='Steel',
    T=30 * module_under_test.u.degC,
    rho=800.0,
    k=2.0,
    e=5.0,
  )
  temperature = material.T

  assert material.name == 'Steel'
  assert getattr(temperature, 'to')(module_under_test.u.degC).magnitude == pytest.approx(30.0)
  assert material.rho == 800 * module_under_test.u.kg / module_under_test.u.m**3
  assert material.k == 2 * module_under_test.u.W / module_under_test.u.m / module_under_test.u.degK
  assert material.e == 5 * module_under_test.u.um

def test_material_setters_update_stored_values() -> None:
  material = module_under_test.Material()

  material.name = 'custom'
  material.T = 40 * module_under_test.u.degC
  material.rho = 950.0
  material.k = 0.6
  material.e = 4.0
  temperature = material.T

  assert material.name == 'custom'
  assert getattr(temperature, 'to')(module_under_test.u.degC).magnitude == pytest.approx(40.0)
  assert material.rho == 950 * module_under_test.u.kg / module_under_test.u.m**3
  assert material.k == 0.6 * module_under_test.u.W / module_under_test.u.m / module_under_test.u.degK
  assert material.e == 4 * module_under_test.u.um

def test_material_to_string_and_repr_cover_detail_levels() -> None:
  material = module_under_test.Material(name='steel', rho=800.0, k=2.0, e=5.0)

  text_basic = material.toString()
  text_detail = material.toString(1)
  text_formatted = f'{material:1}'
  rep = repr(material)

  assert 'Material steel:' in text_basic
  assert 'rho:800.00' in text_basic
  assert 'kg/m' in text_basic
  assert 'T:' in text_detail
  assert 'k:' in text_detail
  assert text_formatted == text_detail
  assert 'Material(name="steel"' in rep

def test_material_update_product_is_safe_without_library_backend() -> None:
  material = module_under_test.Material(mat='steel', rho=700.0, k=3.0, e=7.0)

  material._updateProduct()  # pylint: disable=protected-access

  assert material.cmat is None
  assert material.rho == 700 * module_under_test.u.kg / module_under_test.u.m**3
  assert material.k == 3 * module_under_test.u.W / module_under_test.u.m / module_under_test.u.degK
  assert material.e == 7 * module_under_test.u.um

Tests: test_medium

'''Behavioral unit tests for fluidsolve.medium.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring

import inspect
import pytest
import fluidsolve.medium as module_under_test

u = module_under_test.unitRegistry

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['Medium'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

def test_public_functions_are_callable() -> None:
  public_function_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isfunction)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]

  for name in public_function_names:
    obj = getattr(module_under_test, name)
    assert callable(obj)

@pytest.mark.parametrize(
  'name',
  ['CTE_E_RVS', 'CTE_G', 'CTE_K', 'CTE_MU', 'CTE_NP', 'CTE_NT', 'CTE_NU', 'CTE_RHO', 'CTE_WATER', 'Quantity', 'u', 'unitRegistry'],
)
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

def test_medium_defaults_are_initialized_from_reference_water() -> None:
  medium = module_under_test.Medium()
  temperature = medium.T
  pressure = medium.p
  density = medium.rho
  viscosity = medium.mu
  conductivity = medium.k
  assert medium.name == 'water'
  assert medium.cprd is not None
  assert getattr(temperature, 'to')(u.degC).magnitude == pytest.approx(20.0, rel=1e-3)
  assert getattr(pressure, 'to')(u.bar).magnitude == pytest.approx((1.0 * u.atm).to(u.bar).magnitude, rel=1e-3)
  assert getattr(density, 'magnitude') > 0.0
  assert getattr(viscosity, 'magnitude') > 0.0
  assert getattr(conductivity, 'magnitude') > 0.0

def test_medium_accepts_custom_conditions_and_name() -> None:
  medium = module_under_test.Medium(name='hot_water', T=50.0 * u.degC, p=2.0 * u.bar)
  temperature = medium.T
  pressure = medium.p

  assert medium.name == 'hot_water'
  assert getattr(temperature, 'to')(u.degC).magnitude == pytest.approx(50.0, rel=1e-3)
  assert getattr(pressure, 'to')(u.bar).magnitude == pytest.approx(2.0, rel=1e-3)

def test_medium_manual_properties_allowed_without_thermo_product() -> None:
  medium = module_under_test.Medium(
    prd='',
    name='manual',
    rho=950.0,
    mu=0.0012,
    k=0.55,
  )
  density = medium.rho
  viscosity = medium.mu
  conductivity = medium.k

  assert medium.cprd is None
  assert medium.name == 'manual'
  assert getattr(density, 'to')(u.kg / u.m**3).magnitude == pytest.approx(950.0)
  assert getattr(viscosity, 'to')(u.Pa * u.s).magnitude == pytest.approx(0.0012)
  assert getattr(conductivity, 'to')(u.W / u.m / u.degK).magnitude == pytest.approx(0.55)

def test_medium_without_product_requires_rho_mu_and_k() -> None:
  with pytest.raises(ValueError, match='Medium must have a valid prd or have a rho, mu and k'):
    module_under_test.Medium(prd='')

def test_medium_property_setters_update_values_and_keep_overrides() -> None:
  medium = module_under_test.Medium()

  medium.rho = 975.0
  medium.mu = 0.00105
  medium.k = 0.62
  medium.T = 60.0 * u.degC
  medium.p = 3.0 * u.bar
  temperature = medium.T
  pressure = medium.p
  density = medium.rho
  viscosity = medium.mu
  conductivity = medium.k

  assert getattr(temperature, 'to')(u.degC).magnitude == pytest.approx(60.0, rel=1e-3)
  assert getattr(pressure, 'to')(u.bar).magnitude == pytest.approx(3.0, rel=1e-3)
  assert getattr(density, 'to')(u.kg / u.m**3).magnitude == pytest.approx(975.0, rel=1e-3)
  assert getattr(viscosity, 'to')(u.Pa * u.s).magnitude == pytest.approx(0.00105, rel=1e-4)
  assert getattr(conductivity, 'to')(u.W / u.m / u.degK).magnitude == pytest.approx(0.62, rel=1e-3)

def test_medium_name_setter_and_text_representations() -> None:
  medium = module_under_test.Medium(name='old_name')
  medium.name = 'new_name'

  text_basic = str(medium)
  text_detail = medium.toString(detail=1)
  text_formatted = f'{medium:1}'
  rep = repr(medium)

  assert medium.name == 'new_name'
  assert 'Medium new_name:' in text_basic
  assert 'rho:' in text_basic
  assert 'mu:' in text_basic
  assert 'T:' in text_detail
  assert 'p:' in text_detail
  assert 'k:' in text_detail
  assert text_formatted == text_detail
  assert 'Medium(name="new_name", prd="water"' in rep

def test_medium_repr_for_empty_name_uses_default_signature() -> None:
  medium = module_under_test.Medium(name='')

  assert repr(medium).startswith('Medium(prd="water"')

Tests: test_network

'''Behavioral unit tests for fluidsolve.network.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring,missing-class-docstring,protected-access

import inspect
import types
import numpy as np
import pytest
import fluidsolve.network as module_under_test
import fluidsolve.comp_valve as comp_valve

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['Network'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

def test_public_functions_are_callable() -> None:
  public_function_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isfunction)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]

  for name in public_function_names:
    obj = getattr(module_under_test, name)
    assert callable(obj)

@pytest.mark.parametrize('name', ['Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

class DummyResist(module_under_test.flsb.Comp_Base):
  _group = 'Resistance'
  _part = 'DummyResist'
  _sign = -1.0

  def __init__(self, name: str, head_factor: float=1.0) -> None:
    super().__init__(name=name)
    self.head_factor = head_factor
    self.calls = []

  def calcH(self, Q, sense: int=1, pin: int=1, pout: int=2):
    self.calls.append((Q, sense, pin, pout))
    flow = Q.to(module_under_test.u.m**3 / module_under_test.u.h).magnitude if hasattr(Q, 'to') else float(Q)
    # Dummy friction model: always dissipative head contribution.
    return -self.head_factor * abs(flow) * module_under_test.u.m

class DummyPump(DummyResist):
  _group = 'Pump'
  _part = 'DummyPump'
  _sign = 1.0

class DummyDirectionalResist(module_under_test.flsb.Comp_Base):
  _group = 'Resistance'
  _part = 'DummyDirectionalResist'
  _sign = -1.0

  def __init__(self, name: str, k_forward: float=2.0, k_reverse: float=7.0) -> None:
    super().__init__(name=name)
    self.k_forward = k_forward
    self.k_reverse = k_reverse
    self.calls = []

  def calcH(self, Q, sense: int=1, pin: int=1, pout: int=2):
    self.calls.append((Q, sense, pin, pout))
    flow = Q.to(module_under_test.u.m**3 / module_under_test.u.h).magnitude if hasattr(Q, 'to') else float(Q)
    k = self.k_forward if sense > 0 else self.k_reverse
    return -k * abs(flow) * module_under_test.u.m

def _triangle_network() -> module_under_test.Network:
  return module_under_test.Network(
    name='Loop',
    components=[
      {'comp': DummyPump('P1', head_factor=4.0), 'nodes': ['A', 'B']},
      {'comp': DummyResist('R1', head_factor=1.5), 'nodes': ['B', 'C']},
      {'comp': DummyResist('R2', head_factor=2.0), 'nodes': ['C', 'A']},
    ],
  )

def test_network_defaults_and_empty_strings() -> None:
  network = module_under_test.Network(name='N1')

  assert not network.components
  assert not network.nodes
  assert not network.edges
  assert not network.segments
  assert not network.result
  assert network.nodeString() == ' Nodes (0):\n  ---\n'
  assert network.segmentsString() == ' Segments (0):\n  ---\n'
  assert network.resultString() == ' Result:\n   not yet calculated\n'
  assert network.functionString() == ' Functions: Combined incidence matrix (B:0) (C:0):\n  No segments in network\n'

def test_network_add_components_validates_entries() -> None:
  comp = DummyResist('R1')

  with pytest.raises(ValueError, match='Invalid component entry'):
    module_under_test.Network(components=['bad'])
  with pytest.raises(ValueError, match='must contain "comp" and "nodes"'):
    module_under_test.Network(components=[{'comp': comp}])
  with pytest.raises(ValueError, match='Node count 1 does not match component ports 2'):
    module_under_test.Network(components=[{'comp': comp, 'nodes': ['A']}])
  with pytest.raises(ValueError, match=r'sense must be \+1 or -1'):
    module_under_test.Network(components=[{'comp': comp, 'nodes': ['A', 'B'], 'sense': 0}])
  with pytest.raises(AttributeError):
    module_under_test.Network(components=[{'comp': object(), 'nodes': ['A', 'B']}])
  with pytest.raises(ValueError, match='Invalid nodes'):
    module_under_test.Network(components=[{'comp': comp, 'nodes': 'AB'}])

def test_network_builds_segments_adjacency_tree_and_cycle_matrices() -> None:
  network = _triangle_network()

  assert len(network.components) == 3
  assert [item['comp'].name for item in network.components] == ['P1', 'R1', 'R2']
  assert list(network.nodes) == ['A', 'B', 'C']
  assert len(network.segments) == 3
  assert set(network.edges) == {'P1:A-B', 'R1:B-C', 'R2:C-A'}
  assert network.adjacency['A'][0] == ('P1:A-B', 'B', 1)
  assert ('R2:C-A', 'C', -1) in network.adjacency['A']
  assert len(network.spanningTree) == 2
  assert len(network.cycleBase) == 1
  assert network.funcs['B'].shape == (3, 3)
  assert network.funcs['C'].shape == (1, 3)
  assert sorted(abs(value) for value in network.funcs['C'][0]) == [1.0, 1.0, 1.0]

def test_network_cycle_basis_keeps_full_chord_path_loops() -> None:
  network = module_under_test.Network(
    name='QuadLoop',
    components=[
      {'comp': DummyPump('P1', head_factor=5.0), 'nodes': ['A', 'B']},
      {'comp': DummyResist('R1', head_factor=1.0), 'nodes': ['B', 'C']},
      {'comp': DummyResist('R2', head_factor=1.0), 'nodes': ['C', 'D']},
      {'comp': DummyResist('R3', head_factor=1.0), 'nodes': ['D', 'A']},
      {'comp': DummyResist('R4', head_factor=1.0), 'nodes': ['B', 'D']},
    ],
  )

  assert len(network.cycleBase) == 2
  # No fundamental loop should collapse to a single-segment equation.
  assert all(len(loop) >= 3 for loop in network.cycleBase)
  non_zero_counts = [int(np.count_nonzero(row)) for row in network.funcs['C']]
  assert all(count >= 3 for count in non_zero_counts)

def test_network_solution_invariant_to_segment_node_order() -> None:
  def build(nodes3: list[str]) -> module_under_test.Network:
    return module_under_test.Network(
      name='InvariantOrder',
      components=[
        {'comp': DummyPump('P1', head_factor=4.0), 'nodes': ['A', 'B']},
        {'comp': DummyResist('R1', head_factor=1.0), 'nodes': ['B', 'C']},
        {'comp': DummyResist('R2', head_factor=1.0), 'nodes': nodes3},
        {'comp': DummyPump('P2', head_factor=4.0), 'nodes': ['E', 'D']},
        {'comp': DummyResist('R3', head_factor=1.0), 'nodes': ['E', 'F']},
        {'comp': DummyResist('R4', head_factor=1.0), 'nodes': ['C', 'F']},
        {'comp': DummyResist('R5', head_factor=1.0), 'nodes': ['A', 'F']},
      ],
    )

  net_dc = build(['D', 'C'])
  net_cd = build(['C', 'D'])

  res_dc = {item['segment'].split(':', 1)[1]: item for item in net_dc.calcNetwork()}
  res_cd = {item['segment'].split(':', 1)[1]: item for item in net_cd.calcNetwork()}

  q_ab_dc = res_dc['A-B']['Q'].to(module_under_test.u.m**3 / module_under_test.u.h).magnitude
  q_ab_cd = res_cd['A-B']['Q'].to(module_under_test.u.m**3 / module_under_test.u.h).magnitude
  q_bc_dc = res_dc['B-C']['Q'].to(module_under_test.u.m**3 / module_under_test.u.h).magnitude
  q_bc_cd = res_cd['B-C']['Q'].to(module_under_test.u.m**3 / module_under_test.u.h).magnitude
  q_3_dc = res_dc['D-C']['Q'].to(module_under_test.u.m**3 / module_under_test.u.h).magnitude
  q_3_cd = res_cd['C-D']['Q'].to(module_under_test.u.m**3 / module_under_test.u.h).magnitude

  h_ab_dc = res_dc['A-B']['H'].to(module_under_test.u.m).magnitude
  h_ab_cd = res_cd['A-B']['H'].to(module_under_test.u.m).magnitude
  h_bc_dc = res_dc['B-C']['H'].to(module_under_test.u.m).magnitude
  h_bc_cd = res_cd['B-C']['H'].to(module_under_test.u.m).magnitude
  h_3_dc = res_dc['D-C']['H'].to(module_under_test.u.m).magnitude
  h_3_cd = res_cd['C-D']['H'].to(module_under_test.u.m).magnitude

  assert q_ab_dc == pytest.approx(q_ab_cd)
  assert q_bc_dc == pytest.approx(q_bc_cd)
  assert abs(q_3_dc) == pytest.approx(abs(q_3_cd))
  assert h_ab_dc == pytest.approx(h_ab_cd)
  assert h_bc_dc == pytest.approx(h_bc_cd)
  assert abs(h_3_dc) == pytest.approx(abs(h_3_cd))

def test_network_validation_requires_source_and_resistance_in_loops() -> None:
  with pytest.raises(ValueError, match='no energy source'):
    module_under_test.Network(
      components=[
        {'comp': DummyResist('R1'), 'nodes': ['A', 'B']},
        {'comp': DummyResist('R2'), 'nodes': ['B', 'C']},
        {'comp': DummyResist('R3'), 'nodes': ['C', 'A']},
      ]
    )

  with pytest.raises(ValueError, match='no resistance in loop'):
    module_under_test.Network(
      components=[
        {'comp': DummyPump('P1'), 'nodes': ['A', 'B']},
        {'comp': DummyPump('P2'), 'nodes': ['B', 'C']},
        {'comp': DummyPump('P3'), 'nodes': ['C', 'A']},
      ]
    )

def test_network_detects_duplicate_segments() -> None:
  with pytest.raises(ValueError, match='Duplicate segment R1:A-B'):
    module_under_test.Network(
      components=[
        {'comp': DummyResist('R1'), 'nodes': ['A', 'B']},
        {'comp': DummyResist('R1'), 'nodes': ['A', 'B']},
      ]
    )

def test_network_calc_network_returns_segment_results(monkeypatch) -> None:
  network = module_under_test.Network(
    name='Line',
    components=[{'comp': DummyResist('R1', head_factor=2.0), 'nodes': ['A', 'B']}],
  )
  monkeypatch.setattr(
    module_under_test,
    'root',
    lambda *args, **kwargs: types.SimpleNamespace(success=True, x=np.array([2.5]), message='ok', status=1),
  )
  result = network.calcNetwork(guess=1.2)
  assert len(result) == 1
  assert result[0]['segment'] == 'R1:A-B'
  assert result[0]['Q'].to(module_under_test.u.m**3 / module_under_test.u.h).magnitude == pytest.approx(2.5)
  assert result[0]['H'].to(module_under_test.u.m).magnitude == pytest.approx(-5.0)
  assert network.result == result

def test_network_calc_network_uses_segment_sense_and_ports(monkeypatch) -> None:
  comp_fwd = DummyDirectionalResist('R1', k_forward=2.0, k_reverse=7.0)
  network_fwd = module_under_test.Network(
    name='LineForward',
    components=[{'comp': comp_fwd, 'nodes': ['A', 'B'], 'sense': +1}],
  )
  comp_rev = DummyDirectionalResist('R2', k_forward=2.0, k_reverse=7.0)
  network_rev = module_under_test.Network(
    name='LineReverse',
    components=[{'comp': comp_rev, 'nodes': ['A', 'B'], 'sense': -1}],
  )
  def fake_root(func, x0, method='hybr'):  # pylint: disable=unused-argument
    func(np.asarray(x0, dtype=float))
    return types.SimpleNamespace(success=True, x=np.array([2.5]), message='ok', status=1)
  monkeypatch.setattr(
    module_under_test,
    'root',
    fake_root,
  )

  result_fwd = network_fwd.calcNetwork(guess=1.2)
  result_rev = network_rev.calcNetwork(guess=1.2)

  assert len(comp_fwd.calls) >= 1
  assert len(comp_rev.calls) >= 1
  assert comp_fwd.calls[-1][1:] == (+1, 1, 2)
  assert comp_rev.calls[-1][1:] == (-1, 1, 2)
  assert result_fwd[0]['H'].to(module_under_test.u.m).magnitude == pytest.approx(-5.0)
  assert result_rev[0]['H'].to(module_under_test.u.m).magnitude == pytest.approx(-17.5)

def test_network_calc_network_rejects_inconsistent_or_failed_systems(monkeypatch) -> None:
  network = module_under_test.Network(
    components=[
      {'comp': DummyResist('R1'), 'nodes': ['A', 'B']},
      {'comp': DummyResist('R2'), 'nodes': ['C', 'D']},
    ]
  )

  with pytest.raises(ValueError, match='Inconsistent equation system'):
    network.calcNetwork()

  solvable = module_under_test.Network(
    components=[{'comp': DummyResist('R3'), 'nodes': ['A', 'B']}],
  )
  monkeypatch.setattr(
    module_under_test,
    'root',
    lambda *args, **kwargs: types.SimpleNamespace(success=False, message='failed', status=4),
  )

  with pytest.warns(RuntimeWarning, match='did not converge|failed'):
    result = solvable.calcNetwork()

  assert result[0]['Q'].to(module_under_test.u.m**3 / module_under_test.u.h).magnitude == pytest.approx(0.0)

def test_network_string_helpers_include_topology_and_results() -> None:
  network = _triangle_network()
  network._result = [
    {
      'segment': 'P1:A-B',
      'Q': 2.0 * module_under_test.u.m**3 / module_under_test.u.h,
      'H': 8.0 * module_under_test.u.m,
    }
  ]

  text = network.toString(detail=1)
  text_formatted = f'{network:1}'
  validation = network.networkValidationtoString()

  assert 'Network "Loop"' in text
  assert text_formatted == text
  assert 'Nodes (3):' in text
  assert 'A, B, C' in text
  assert 'Segments (3):' in text
  assert 'Adjacency (3):' in text
  assert 'node' in text
  assert 'links' in text
  assert 'A    |' in text
  assert 'P1:A-B' in text
  assert '-> B' in text
  assert 'SpanningTree' in text
  assert 'segment' in text
  assert 'path' in text
  assert 'sense' in text
  assert '+1' in text
  assert 'CycleBase' in text
  assert 'Loop 1:' in text
  assert 'Functions: Combined incidence matrix (B:3) (C:1):' in text
  assert 'Result:' in text
  assert 'P1:A-B' in text
  assert 'Loop 1:' in validation
  assert 'Power' in validation
  assert 'Resist' in validation

def test_network_rebuilds_segments_when_valve_state_changes() -> None:
  network = module_under_test.Network(
    name='ValveLoop',
    components=[
      {'comp': DummyPump('P1', head_factor=4.0), 'nodes': ['A', 'B']},
      {'comp': comp_valve.Comp_Valve_3W(name='V1', D=50, state=1), 'nodes': ['B', 'C', 'D']},
      {'comp': DummyResist('R1', head_factor=1.5), 'nodes': ['C', 'A']},
      {'comp': DummyResist('R2', head_factor=1.5), 'nodes': ['D', 'A']},
    ],
  )

  def monkey_root(*_args, **_kwargs):
    return types.SimpleNamespace(success=True, x=np.array([1.0, 1.0, 1.0, 1.0]), message='ok', status=1)

  original_root = module_under_test.root
  module_under_test.root = monkey_root

  def _line_for(segment_name: str, text: str) -> str:
    for line in text.splitlines():
      if segment_name in line:
        return line
    return ''

  try:
    network.calcNetwork(guess=1.0)
    keys_state_1 = set(network.segments.keys())
    assert 'V1:B-C' in keys_state_1
    assert 'V1:B-D' in keys_state_1
    assert network.segments['V1:B-C']['use'] is True
    assert network.segments['V1:B-D']['use'] is False
    text_state_1 = network.segmentsString()
    assert 'comp' in text_state_1
    assert 'nodes' in text_state_1
    assert 'type' in text_state_1
    assert 'ports' in text_state_1
    line_1_used = _line_for('V1:B-C', text_state_1)
    line_1_unused = _line_for('V1:B-D', text_state_1)
    assert '[unused]' not in line_1_used
    assert line_1_used.startswith('   V1:B-C')
    assert ' | ' in line_1_used
    assert 'Comp_Valve_3W' in line_1_used
    assert '1 → 3' in line_1_unused
    assert line_1_unused.startswith('[[ V1:B-D')
    assert line_1_unused.endswith(' ]]')

    network.components[1]['comp'].state = 2
    network.calcNetwork(guess=1.0)
    keys_state_2 = set(network.segments.keys())
    assert 'V1:B-D' in keys_state_2
    assert 'V1:B-C' in keys_state_2
    assert network.segments['V1:B-C']['use'] is False
    assert network.segments['V1:B-D']['use'] is True
    text_state_2 = network.segmentsString()
    line_2_unused = _line_for('V1:B-C', text_state_2)
    line_2_used = _line_for('V1:B-D', text_state_2)
    assert line_2_unused.startswith('[[ V1:B-C')
    assert line_2_unused.endswith(' ]]')
    assert '[unused]' not in line_2_used
    assert line_2_used.startswith('   V1:B-D')
    assert ' | ' in line_2_used
  finally:
    module_under_test.root = original_root

Tests: test_path

'''Behavioral unit tests for fluidsolve.path.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring,missing-class-docstring,protected-access

import inspect
import pytest
import fluidsolve.path as module_under_test

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['Path'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

def test_public_functions_are_callable() -> None:
  public_function_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isfunction)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]

  for name in public_function_names:
    obj = getattr(module_under_test, name)
    assert callable(obj)

@pytest.mark.parametrize('name', ['Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

class DummyComp(module_under_test.flsb.Comp_Base):
  _group = 'Test'
  _part = 'Dummy'
  _nports = 2

  def __init__(self, name: str, head: float=0.0, pressure: float=0.0) -> None:
    super().__init__(name=name)
    self.head = head
    self.pressure = pressure
    self.calls = []

  def calcH(self, Q, sense: int=1, pin: int=1, pout: int=2):
    self.calls.append(('H', Q, sense, pin, pout))
    return self.head * sense * module_under_test.u.m

  def calcP(self, Q, sense: int=1, pin: int=1, pout: int=2):
    self.calls.append(('P', Q, sense, pin, pout))
    return self.pressure * sense * module_under_test.u.bar

class DummyValve(module_under_test.flsb.Comp_Base):
  _group = 'Valve'
  _part = 'Valve'
  _nports = 3

  def __init__(self, name: str='V1', head: float=0.0) -> None:
    super().__init__(name=name)
    self.head = head
    self.calls = []

  def calcH(self, Q, sense: int=1, pin: int=1, pout: int=2):
    self.calls.append(('H', Q, sense, pin, pout))
    return self.head * sense * module_under_test.u.m

def test_path_defaults_and_accessors() -> None:
  path = module_under_test.Path(name='Loop')

  assert path.name == 'Loop'
  assert not path.components
  assert path.componentsString() == '   <none>\n\n'
  assert str(path) == 'Path "Loop"\n'

def test_path_add_components_normalizes_two_port_entries() -> None:
  comp = DummyComp('P1', head=2.0)
  path = module_under_test.Path(components=[{'comp': comp, 'sense': -1}])

  item = path.getComp(0)
  assert item == {'comp': comp, 'sense': -1, 'pin': 1, 'pout': 2}

  replacement = {'comp': comp, 'sense': 1, 'pin': 1, 'pout': 2}
  assert path.setComp(0, replacement) is replacement
  assert path.getComp(0) is replacement

def test_path_add_components_requires_valid_entries() -> None:
  comp = DummyComp('P1')
  valve = DummyValve('V1')

  with pytest.raises(ValueError, match='dict expected'):
    module_under_test.Path(components=['bad'])
  with pytest.raises(ValueError, match='missing key "comp"'):
    module_under_test.Path(components=[{'sense': 1}])
  with pytest.raises(ValueError, match='Unknown component'):
    module_under_test.Path(components=[{'comp': object()}])
  with pytest.raises(ValueError, match=r'sense must be \+1 or -1'):
    module_under_test.Path(components=[{'comp': comp, 'sense': 0}])
  with pytest.raises(ValueError, match='need pin and pout'):
    module_under_test.Path(components=[{'comp': valve}])
  with pytest.raises(ValueError, match='Invalid ports'):
    module_under_test.Path(components=[{'comp': valve, 'pin': 0, 'pout': 4}])

def test_path_add_components_keeps_explicit_ports_for_multiport_components() -> None:
  valve = DummyValve('V1', head=1.5)
  path = module_under_test.Path(components=[{'comp': valve, 'sense': -1, 'pin': 3, 'pout': 2}])

  assert path.getComp(0) == {'comp': valve, 'sense': -1, 'pin': 3, 'pout': 2}

def test_path_calcH_and_calcP_sum_component_results_with_sense() -> None:
  comp1 = DummyComp('A', head=2.0, pressure=0.5)
  comp2 = DummyComp('B', head=3.0, pressure=1.5)
  path = module_under_test.Path(
    components=[
      {'comp': comp1, 'sense': 1},
      {'comp': comp2, 'sense': -1},
    ]
  )

  total_h = path.calcH(4 * module_under_test.u.m**3 / module_under_test.u.h, sense=-1)
  total_p = path.calcP(4 * module_under_test.u.m**3 / module_under_test.u.h, sense=-1)

  assert total_h.to(module_under_test.u.m).magnitude == pytest.approx(1.0)
  assert total_p.to(module_under_test.u.bar).magnitude == pytest.approx(1.0)
  assert comp1.calls[0][2:] == (-1, 1, 2)
  assert comp2.calls[0][2:] == (1, 1, 2)
  assert comp1.calls[1][2:] == (-1, 1, 2)
  assert comp2.calls[1][2:] == (1, 1, 2)

def test_path_calcHprofile_returns_incremental_and_total_points() -> None:
  comp1 = DummyComp('A', head=2.0)
  comp2 = DummyComp('B', head=3.0)
  path = module_under_test.Path(components=[{'comp': comp1}, {'comp': comp2}])

  points = path.calcHprofile(5, incr=True)

  assert [point.name for point in points] == ['0:A', '1:B', 'Tot']
  assert [point.Qmag for point in points] == [5.0, 5.0, 5.0]
  assert [point.Hmag for point in points] == [2.0, 5.0, 5.0]

def test_path_calcHprofile_non_incremental_uses_component_head_per_step() -> None:
  comp1 = DummyComp('A', head=2.0)
  comp2 = DummyComp('B', head=3.0)
  path = module_under_test.Path(components=[{'comp': comp1}, {'comp': comp2}])

  points = path.calcHprofile(5, incr=False, sense=-1)

  assert [point.Hmag for point in points] == [-2.0, -3.0, -5.0]
  assert comp1.calls[0][2:] == (-1, 1, 2)
  assert comp2.calls[0][2:] == (-1, 1, 2)

def test_path_to_string_formats_component_listing_and_detail() -> None:
  comp1 = DummyComp('PumpA', head=2.0)
  valve = DummyValve('Valve1', head=1.0)
  path = module_under_test.Path(
    name='Loop',
    components=[
      {'comp': comp1, 'sense': 1},
      {'comp': valve, 'sense': -1, 'pin': 3, 'pout': 1},
    ]
  )

  text = path.toString(detail=1)

  assert 'Path "Loop"' in text
  assert 'Components (2):' in text
  assert 'idx | Comp' in text
  assert 'PumpA' in text
  assert 'Valve1' in text
  assert ' |  \u2192  | ' in text
  assert ' |  \u2190  | ' in text
  assert '3 -> 1' in text

Tests: test_plotext

'''Behavioral unit tests for fluidsolve.plotext.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring,missing-class-docstring,protected-access,unused-argument

import inspect
from types import SimpleNamespace
import numpy as np
import pytest
import fluidsolve.plotext as module_under_test

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['PlotQHcurve', 'PlotSimple'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

def test_public_functions_are_callable() -> None:
  public_function_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isfunction)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]

  for name in public_function_names:
    obj = getattr(module_under_test, name)
    assert callable(obj)

@pytest.mark.parametrize('name', ['Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

class DummyFigure:
  def __init__(self, **kwargs):
    self.kwargs = kwargs
    self.hw = kwargs.get('hw', 50)
    self.nrw = kwargs.get('nrw', 1)
    self.ncw = kwargs.get('ncw', 1)
    self.prepare_show_calls = 0
    self.show_calls = 0
    self.update_calls = 0
    self.update_data_calls = 0

  def prepareShow(self) -> None:
    self.prepare_show_calls += 1

  def show(self) -> None:
    self.show_calls += 1

  def update(self) -> None:
    self.update_calls += 1

  def updateData(self) -> None:
    self.update_data_calls += 1

class DummyGraph:
  def __init__(self, figure, r=0, c=0):
    self.figure = figure
    self.r = r
    self.c = c
    self.xaxis = None
    self.yaxis = None
    self.grid = None

  def setXAxis(self, **kwargs) -> None:
    self.xaxis = kwargs

  def setYAxis(self, **kwargs) -> None:
    self.yaxis = kwargs

  def setGrid(self, **kwargs) -> None:
    self.grid = kwargs

class DummyCurve:
  def __init__(self, graph, **kwargs):
    self.graph = graph
    self.kwargs = kwargs
    self.x = None
    self.y = None

class DummyAnnotation:
  def __init__(self, graph, **kwargs):
    self.graph = graph
    self.kwargs = kwargs
    self.x = None
    self.y = None
    self.label = None

class DummyButton:
  def __init__(self, figure, **kwargs):
    self.figure = figure
    self.kwargs = kwargs

class DummySlider:
  def __init__(self, figure, **kwargs):
    self.figure = figure
    self.kwargs = kwargs
    self.reset_calls = 0
    self.widget = SimpleNamespace(reset=self._reset)

  def _reset(self) -> None:
    self.reset_calls += 1

def _install_plot_stubs(monkeypatch) -> None:
  monkeypatch.setattr(module_under_test.flsp, 'PlotFigure', DummyFigure)
  monkeypatch.setattr(module_under_test.flsp, 'PlotGraph', DummyGraph)
  monkeypatch.setattr(module_under_test.flsp, 'PlotCurve', DummyCurve)
  monkeypatch.setattr(module_under_test.flsp, 'PlotAnnotation', DummyAnnotation)
  monkeypatch.setattr(module_under_test.flsp, 'PlotButton', DummyButton)
  monkeypatch.setattr(module_under_test.flsp, 'PlotSlider', DummySlider)

def test_plot_qhcurve_initializes_graph_axes_and_optional_widgets(monkeypatch) -> None:
  _install_plot_stubs(monkeypatch)

  plotter = module_under_test.PlotQHcurve(
    xmin=1,
    xmax=9,
    xstep=2,
    ymin=0,
    ymax=12,
    ystep=3,
    xlabel='Flow',
    ylabel='Head',
    sliders=[{'label': 'Speed'}],
    title='Plot',
  )
  fig_kwargs = getattr(plotter._fig, 'kwargs')
  graph_xaxis = getattr(plotter._graph, 'xaxis')
  graph_yaxis = getattr(plotter._graph, 'yaxis')
  graph_grid = getattr(plotter._graph, 'grid')

  assert isinstance(plotter._fig, DummyFigure)
  assert isinstance(plotter._graph, DummyGraph)
  assert fig_kwargs == {'title': 'Plot'}
  assert graph_xaxis == {'vmin': 1, 'vmax': 9, 'vstep': 2, 'labeltxt': 'Flow'}
  assert graph_yaxis == {'vmin': 0, 'vmax': 12, 'vstep': 3, 'labeltxt': 'Head'}
  assert graph_grid == {'axis': 'both'}
  assert plotter._fig.hw == 60
  assert plotter._fig.nrw == 2
  assert plotter._fig.ncw == 10
  assert isinstance(plotter._buttonreset, DummyButton)
  assert len(plotter._sliders) == 1
  assert getattr(plotter._sliders[0], 'kwargs')['label'] == 'Speed'
  assert getattr(plotter._sliders[0], 'kwargs')['r'] == 1
  assert getattr(plotter._sliders[0], 'kwargs')['c'] == '0:9'

def test_prepare_show_creates_plot_objects_and_populates_data(monkeypatch) -> None:
  _install_plot_stubs(monkeypatch)

  class DummyPump:
    def __init__(self):
      self.Qb = SimpleNamespace(magnitude=1.0)
      self.Qe = SimpleNamespace(magnitude=4.0)

    def calcH(self, flow, sense):
      return SimpleNamespace(magnitude=np.array([9.0, 7.0, 0.0, -1.0]))

  class DummyCircuit:
    def calcH(self, flow, sense):
      return SimpleNamespace(magnitude=np.array([-1.0, -2.0, -3.0, -4.0]))

  class DummyPoint:
    def __init__(self, name: str, qmag: float, hmag: float):
      self.name = name
      self.Qmag = qmag
      self.Hmag = hmag
      self.update_calls = 0

    def update(self) -> None:
      self.update_calls += 1

  monkeypatch.setattr(module_under_test.np, 'linspace', lambda start, stop, count: np.array([start, 2.0, 3.0, stop]))
  monkeypatch.setattr(module_under_test.np, 'argmax', lambda values: next((i for i, value in enumerate(values) if value), 0))

  wpoint = DummyPoint('WP1', 2.5, 6.0)
  spoint = DummyPoint('SP1', 1.5, 3.0)
  plotter = module_under_test.PlotQHcurve(
    pumps=[DummyPump()],
    circuits=[DummyCircuit()],
    wpoints=[wpoint],
    spoints=[spoint],
    npts=4,
    Qmax=8,
  )

  plotter.prepareShow()
  prepare_show_calls = getattr(plotter._fig, 'prepare_show_calls')

  assert plotter._prepare is False
  assert prepare_show_calls == 1
  assert len(plotter._curvepumps) == 1
  assert len(plotter._curvecircuits) == 1
  assert len(plotter._curvewpts) == 1
  assert len(plotter._curvespts) == 1
  assert np.allclose(np.asarray(plotter._curvepumps[0].x), np.asarray([1.0, 2.0]))
  assert np.allclose(np.asarray(plotter._curvepumps[0].y), np.asarray([9.0, 7.0]))
  assert np.allclose(np.asarray(plotter._curvecircuits[0].x), np.asarray([0.001, 2.0, 3.0, 8.0]))
  assert np.allclose(np.asarray(plotter._curvecircuits[0].y), np.asarray([1.0, 2.0, 3.0, 4.0]))
  assert plotter._curvewpts[0].x == [2.5]
  assert plotter._curvewpts[0].y == [6.0]
  assert plotter._annotationwpts[0].label == ['WP1']
  assert plotter._curvespts[0].x == [1.5]
  assert plotter._curvespts[0].y == [3.0]
  assert plotter._annotationspts[0].label == ['SP1']
  assert wpoint.update_calls == 1
  assert spoint.update_calls == 1

def test_prepare_show_runs_only_once_and_show_delegates(monkeypatch) -> None:
  _install_plot_stubs(monkeypatch)

  plotter = module_under_test.PlotQHcurve()

  plotter.prepareShow()
  plotter.prepareShow()
  plotter.show()
  prepare_show_calls = getattr(plotter._fig, 'prepare_show_calls')
  show_calls = getattr(plotter._fig, 'show_calls')

  assert prepare_show_calls == 1
  assert show_calls == 1

def test_update_and_update_data_delegate_to_figure(monkeypatch) -> None:
  _install_plot_stubs(monkeypatch)
  plotter = module_under_test.PlotQHcurve()

  calls = []
  monkeypatch.setattr(plotter, '_calcAndUpdate', lambda: calls.append('calc'))

  plotter.update()
  plotter.updateData()
  update_calls = getattr(plotter._fig, 'update_calls')
  update_data_calls = getattr(plotter._fig, 'update_data_calls')

  assert calls == ['calc', 'calc']
  assert update_calls == 1
  assert update_data_calls == 1

def test_reset_controls_resets_each_slider(monkeypatch) -> None:
  _install_plot_stubs(monkeypatch)
  plotter = module_under_test.PlotQHcurve(sliders=[{'label': 'A'}, {'label': 'B'}])

  plotter._resetControls(event=None)

  assert [slider.reset_calls for slider in plotter._sliders] == [1, 1]


def test_plot_simple_initializes_single_graph_with_provided_data(monkeypatch) -> None:
  _install_plot_stubs(monkeypatch)

  plotter = module_under_test.PlotSimple(
    x=[1, 2],
    y=[3, 4],
    type='line',
    xlabel='X',
    ylabel='Y',
    xmin=0,
    xmax=10,
    xstep=2,
    ymin=0,
    ymax=20,
    ystep=5,
    title='Simple',
  )
  plotter.prepareShow()

  assert isinstance(plotter._fig, DummyFigure)
  assert isinstance(plotter._graph, DummyGraph)
  assert getattr(plotter._fig, 'kwargs') == {'title': 'Simple'}
  assert getattr(plotter._graph, 'xaxis') == {'vmin': 0, 'vmax': 10, 'vstep': 2, 'labeltxt': 'X'}
  assert getattr(plotter._graph, 'yaxis') == {'vmin': 0, 'vmax': 20, 'vstep': 5, 'labeltxt': 'Y'}
  assert getattr(plotter._graph, 'grid') == {'axis': 'both'}
  assert isinstance(plotter._curve, DummyCurve)
  assert getattr(plotter._curve, 'kwargs')['x'] == [1, 2]
  assert getattr(plotter._curve, 'kwargs')['y'] == [3, 4]


def test_plot_simple_set_data_and_update_paths(monkeypatch) -> None:
  _install_plot_stubs(monkeypatch)

  plotter = module_under_test.PlotSimple(x=[1], y=[2])
  plotter.prepareShow()
  plotter.setData([2, 3], [4, 5])
  plotter.update()
  plotter.updateData()

  assert plotter._curve.x == [2, 3]
  assert plotter._curve.y == [4, 5]
  assert getattr(plotter._fig, 'update_calls') == 1
  assert getattr(plotter._fig, 'update_data_calls') == 1

Tests: test_plotlib

'''Behavioral unit tests for fluidsolve.plotlib.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring,missing-class-docstring,protected-access,unused-argument,disallowed-name

import inspect
from types import SimpleNamespace
import pytest
import fluidsolve.plotlib as module_under_test

class DummyParent:
  def __init__(self, axes=None):
    self.axes = axes if axes is not None else DummyAxes()
    self._xaxis2 = None
    self._yaxis2 = None

  def addCurve(self, _curve):
    return 0

  def addAnnotation(self, _annotation):
    return 0

  def getAxes(self, axis='main'):
    if axis in ('main', 'x1', 'y1'):
      return self.axes
    if axis == 'x2':
      return None if self._xaxis2 is None else self._xaxis2.axes
    if axis == 'y2':
      return None if self._yaxis2 is None else self._yaxis2.axes
    raise ValueError(f'Invalid axis {axis}')

  def getAllAxes(self):
    axes = [self.axes]
    for axis in (self._xaxis2, self._yaxis2):
      if axis is not None and axis.axes is not None and axis.axes not in axes:
        axes.append(axis.axes)
    return axes

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['PlotAnnotation', 'PlotAxis', 'PlotButton', 'PlotCurve', 'PlotFigure', 'PlotGraph', 'PlotGrid', 'PlotLine', 'PlotSlider'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

def test_public_functions_are_callable() -> None:
  public_function_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isfunction)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]

  for name in public_function_names:
    obj = getattr(module_under_test, name)
    assert callable(obj)

def test_public_variables_exist() -> None:
  public_variable_names = [
    name
    for name, obj in inspect.getmembers(module_under_test)
    if not name.startswith('_')
    and not inspect.isclass(obj)
    and not inspect.isfunction(obj)
    and getattr(obj, '__module__', module_under_test.__name__) == module_under_test.__name__
  ]

  for name in public_variable_names:
    assert hasattr(module_under_test, name)

class DummyCanvas:
  def __init__(self):
    self.draw_idle_calls = 0

  def draw_idle(self) -> None:
    self.draw_idle_calls += 1

class DummyFigureObject:
  def __init__(self):
    self.canvas = DummyCanvas()
    self.suptitle_calls = []
    self.subplots = []

  def suptitle(self, title: str, **kwargs) -> None:
    self.suptitle_calls.append((title, kwargs))

  def add_subplot(self, spec, **kwargs):
    axis = DummyAxes()
    self.subplots.append((spec, kwargs, axis))
    return axis

class DummyGridSpec:
  def __init__(self, nrows: int, ncols: int, figure=None):
    self.nrows = nrows
    self.ncols = ncols
    self.figure = figure

  def __getitem__(self, item):
    return item

class DummyAxes:
  def __init__(self):
    self.calls = []
    self.xaxis = SimpleNamespace(set_minor_locator=lambda loc: self.calls.append(('xminor', loc)))
    self.yaxis = SimpleNamespace(set_minor_locator=lambda loc: self.calls.append(('yminor', loc)))
    self.legend_handles = []
    self.legend_labels = []

  def set_title(self, *args, **kwargs):
    self.calls.append(('set_title', args, kwargs))

  def set_xlim(self, *args, **kwargs):
    self.calls.append(('set_xlim', args, kwargs))

  def set_xticks(self, *args, **kwargs):
    self.calls.append(('set_xticks', args, kwargs))

  def set_ylim(self, *args, **kwargs):
    self.calls.append(('set_ylim', args, kwargs))

  def set_yticks(self, *args, **kwargs):
    self.calls.append(('set_yticks', args, kwargs))

  def set_xlabel(self, *args, **kwargs):
    self.calls.append(('set_xlabel', args, kwargs))

  def set_ylabel(self, *args, **kwargs):
    self.calls.append(('set_ylabel', args, kwargs))

  def tick_params(self, *args, **kwargs):
    self.calls.append(('tick_params', args, kwargs))

  def sharex(self, other):
    self.calls.append(('sharex', other))

  def sharey(self, other):
    self.calls.append(('sharey', other))

  def twinx(self):
    twin = DummyAxes()
    self.calls.append(('twinx', twin))
    return twin

  def twiny(self):
    twin = DummyAxes()
    self.calls.append(('twiny', twin))
    return twin

  def legend(self, **kwargs):
    self.calls.append(('legend', kwargs))

  def get_legend_handles_labels(self):
    return self.legend_handles, self.legend_labels

  def grid(self, **kwargs):
    self.calls.append(('grid', kwargs))

  def annotate(self, *args, **kwargs):
    self.calls.append(('annotate', args, kwargs))
    return SimpleNamespace(remove=lambda: self.calls.append(('remove_anno',)))

  def plot(self, x, y, **kwargs):
    line = SimpleNamespace(
      set_xdata=lambda data: self.calls.append(('line_x', data)),
      set_ydata=lambda data: self.calls.append(('line_y', data)),
    )
    self.calls.append(('plot', x, y, kwargs))
    return [line]

  def scatter(self, x, y, **kwargs):
    obj = SimpleNamespace(set_offsets=lambda data: self.calls.append(('scatter_offsets', data.tolist() if hasattr(data, 'tolist') else data)))
    self.calls.append(('scatter', x, y, kwargs))
    return obj

  def bar(self, x, **kwargs):
    bar = SimpleNamespace(
      set_xdata=lambda data: self.calls.append(('bar_x', data)),
      set_ydata=lambda data: self.calls.append(('bar_y', data)),
    )
    self.calls.append(('bar', x, kwargs))
    return [bar]

class DummyWidget:
  def __init__(self):
    self.callbacks = []

  def on_clicked(self, callback):
    self.callbacks.append(callback)

  def on_changed(self, callback):
    self.callbacks.append(callback)

def test_plotfigure_prepare_show_and_update_paths(monkeypatch) -> None:
  created_figures = []

  def fake_figure(**kwargs):
    fig = DummyFigureObject()
    created_figures.append((kwargs, fig))
    return fig

  monkeypatch.setattr(module_under_test.plt, 'figure', fake_figure)
  monkeypatch.setattr(module_under_test.gridspec, 'GridSpec', DummyGridSpec)

  fig = module_under_test.PlotFigure(title='Title', nr=2, nc=3, nrw=2, ncw=4)
  graph = SimpleNamespace(show_calls=0, update_calls=0, update_data_calls=0)
  graph.show = lambda: setattr(graph, 'show_calls', graph.show_calls + 1)
  graph.update = lambda: setattr(graph, 'update_calls', graph.update_calls + 1)
  graph.updateData = lambda: setattr(graph, 'update_data_calls', graph.update_data_calls + 1)
  fig.addGraph(graph)
  fig.addButton(SimpleNamespace(show=lambda: None))
  fig.addSlider(SimpleNamespace(show=lambda: None))

  fig.prepareShow()
  fig.update()
  fig.updateData()

  assert len(created_figures) == 2
  assert graph.show_calls == 1
  assert graph.update_calls == 1
  assert graph.update_data_calls == 1
  assert getattr(fig.figure, 'suptitle_calls')[0][0] == 'Title'
  assert fig.gridspec.nrows == 2
  assert fig.gridspec.ncols == 3
  assert fig.gridspec_widgets.nrows == 2
  assert fig.gridspec_widgets.ncols == 4
  assert getattr(fig.figure, 'canvas').draw_idle_calls == 2

def test_plotgraph_show_creates_axes_and_invokes_children() -> None:
  fig = module_under_test.PlotFigure()
  fig._fig = DummyFigureObject()
  fig._gs = DummyGridSpec(1, 1, figure=fig._fig)

  graph = module_under_test.PlotGraph(fig, r='0:1', c=':')
  graph.setXAxis(vmin=0, vmax=10, vstep=5, labeltxt='Q')
  graph.setYAxis(vmin=0, vmax=10, vstep=5, labeltxt='H')
  graph.setGrid(axis='both')

  curve = SimpleNamespace(show_calls=0, update_calls=0, update_data_calls=0)
  curve.show = lambda: setattr(curve, 'show_calls', curve.show_calls + 1)
  curve.update = lambda: setattr(curve, 'update_calls', curve.update_calls + 1)
  curve.updateData = lambda: setattr(curve, 'update_data_calls', curve.update_data_calls + 1)
  annotation = SimpleNamespace(show_calls=0, update_calls=0, update_data_calls=0)
  annotation.show = lambda: setattr(annotation, 'show_calls', annotation.show_calls + 1)
  annotation.update = lambda: setattr(annotation, 'update_calls', annotation.update_calls + 1)
  annotation.updateData = lambda: setattr(annotation, 'update_data_calls', annotation.update_data_calls + 1)
  graph._curves.append(curve)
  graph._annotations.append(annotation)

  graph.show()
  graph.update()
  graph.updateData()

  assert graph.axes is not None
  assert curve.show_calls == 1
  assert curve.update_calls == 1
  assert curve.update_data_calls == 1
  assert annotation.show_calls == 1
  assert annotation.update_calls == 1
  assert annotation.update_data_calls == 1

def test_plotcurve_line_scatter_bar_show_and_update_data() -> None:
  parent = DummyParent()

  line = module_under_test.PlotCurve(parent, type='line', x=[1, 2], y=[3, 4])
  line.show()
  line.x = [2, 3]
  line.y = [4, 5]
  line.updateData()

  scatter = module_under_test.PlotCurve(parent, type='scatter', x=[1, 2], y=[3, 4])
  scatter.show()
  scatter.x = [2, 3]
  scatter.y = [5, 6]
  scatter.updateData()

  bar = module_under_test.PlotCurve(parent, type='bar', x=[1, 2], y=[3, 4])
  bar.show()
  bar.x = [2, 3]
  bar.y = [6, 7]
  bar.updateData()

  calls = parent.axes.calls
  assert any(c[0] == 'plot' for c in calls)
  assert any(c[0] == 'scatter' for c in calls)
  assert any(c[0] == 'bar' for c in calls)
  assert any(c[0] == 'line_x' for c in calls)
  assert any(c[0] == 'scatter_offsets' for c in calls)
  assert any(c[0] == 'bar_y' for c in calls)

def test_plotcurve_can_target_secondary_y_axis() -> None:
  parent = DummyParent()
  parent._yaxis2 = module_under_test.PlotAxis(parent, type='y2', labeltxt='Q')
  parent._yaxis2.show()

  curve = module_under_test.PlotCurve(parent, type='line', x=[1, 2], y=[3, 4], axis='y2', label='Flow')
  curve.show()

  assert any(c[0] == 'twinx' for c in parent.axes.calls)
  twin_axes = parent._yaxis2.axes
  assert twin_axes is not None
  assert any(c[0] == 'plot' and c[3]['label'] == 'Flow' for c in twin_axes.calls)

def test_plotcurve_raises_when_secondary_axis_is_missing() -> None:
  parent = DummyParent()

  with pytest.raises(ValueError, match='Axis y2 is not configured'):
    module_under_test.PlotCurve(parent, type='line', x=[1], y=[2], axis='y2').show()

def test_plotannotation_validates_and_updates_annotations() -> None:
  parent = DummyParent()
  annotation = module_under_test.PlotAnnotation(parent, x=[1, 2], y=[3, 4], label=['A', 'B'], xtoggle=1)
  annotation.show()
  annotation.updateData()

  assert len(annotation._annotations) == 2

  bad = module_under_test.PlotAnnotation(parent, x=[1], y=[2, 3], label=['A'])
  with pytest.raises(ValueError, match='Size of x list'):
    bad.show()

def test_plotaxis_grid_and_extra_validation() -> None:
  graph = DummyParent()
  axis = module_under_test.PlotAxis(graph, type='x1', vmin=0, vmax=10, vstep=5, labeltxt='Q')
  axis.show()

  grid = module_under_test.PlotGrid(graph, axis='both', color='gray')
  grid.show()

  with pytest.raises(ValueError, match='Need vmin and vmax when vstep is provided'):
    module_under_test.PlotAxis(graph, type='y1', vmin=0, vstep=1).show()
  with pytest.raises(ValueError, match='Invalid extra'):
    grid.setExtra('bad', alpha=0.5)

def test_plotaxis_applies_manual_limits_even_when_auto_ticks_remain_enabled() -> None:
  graph = DummyParent()

  axis = module_under_test.PlotAxis(graph, type='y1', vmax=30)
  axis.show()

  assert ('set_ylim', (), {'bottom': None, 'top': 30}) in graph.axes.calls

def test_plotlegend_collects_entries_from_secondary_axes() -> None:
  graph = module_under_test.PlotGraph(module_under_test.PlotFigure(), r=0, c=0)
  graph._ax = DummyAxes()
  graph.setYAxis2(labeltxt='Q')
  graph._yaxis2.show()
  graph.axes.legend_handles = ['h1']
  graph.axes.legend_labels = ['Level']
  graph.getAxes('y2').legend_handles = ['h2']
  graph.getAxes('y2').legend_labels = ['Flow']

  legend = module_under_test.PlotLegend(graph, loc='upper right')
  legend.show()

  legend_calls = [call for call in graph.axes.calls if call[0] == 'legend']
  assert legend_calls
  kwargs = legend_calls[-1][1]
  assert kwargs['handles'] == ['h1', 'h2']
  assert kwargs['labels'] == ['Level', 'Flow']

def test_plotbutton_and_plotslider_show_bind_callbacks(monkeypatch) -> None:
  monkeypatch.setattr(module_under_test, 'Button', lambda *args, **kwargs: DummyWidget())
  monkeypatch.setattr(module_under_test, 'Slider', lambda *args, **kwargs: DummyWidget())

  fig = module_under_test.PlotFigure()
  fig._figwidgets = DummyFigureObject()
  fig._gswidgets = DummyGridSpec(2, 2, figure=fig._figwidgets)

  button = module_under_test.PlotButton(fig, r=0, c=0, label='Run', fun=lambda event: None)
  slider = module_under_test.PlotSlider(fig, r=1, c=0, label='S', vmin=0, vmax=10, fun=lambda value: None)
  button.show()
  slider.show()
  button_widget = getattr(button, '_widget')
  slider_widget = getattr(slider, '_widget')
  button_callbacks = getattr(button_widget, 'callbacks')
  slider_callbacks = getattr(slider_widget, 'callbacks')

  assert button_widget is not None
  assert slider_widget is not None
  assert len(button_callbacks) == 1
  assert len(slider_callbacks) == 1

Tests: test_util

'''Behavioral unit tests for fluidsolve.util.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring,missing-class-docstring,protected-access,unused-argument

import inspect
import pytest
import fluidsolve.util as module_under_test

u = module_under_test.u

def test_module_importable() -> None:
  assert module_under_test is not None

def test_public_classes_exist() -> None:
  public_class_names = [
    name
    for name, obj in inspect.getmembers(module_under_test, inspect.isclass)
    if obj.__module__ == module_under_test.__name__ and not name.startswith('_')
  ]

  for name in public_class_names:
    obj = getattr(module_under_test, name)
    assert inspect.isclass(obj)

@pytest.mark.parametrize('name', ['CvtoK', 'CvtoKv', 'FdtoK', 'Htop', 'KtoCv', 'KtoFd', 'KtoH', 'KtoKv', 'Ktop', 'KvtoCv', 'KvtoK', 'Qtov', 'calcCurve', 'calcOrifice', 'calcOrifice2', 'ptoH', 'vtoQ'])
def test_public_functions_are_callable(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert callable(obj)

@pytest.mark.parametrize('name', ['Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

def test_k_fd_conversions_roundtrip() -> None:
  k_loss = 3.2
  length = 12 * u.m
  diameter = 80 * u.mm

  fd = module_under_test.KtoFd(k_loss, length, diameter)
  k_back = module_under_test.FdtoK(fd, length, diameter)

  assert k_back == pytest.approx(k_loss)

def test_kv_cv_and_k_conversions_roundtrip() -> None:
  diameter = 50 * u.mm
  kv = 25 * u.m**3 / u.h

  cv = module_under_test.KvtoCv(kv)
  kv_back = module_under_test.CvtoKv(cv)

  assert kv_back.to(u.m**3 / u.h).magnitude == pytest.approx(kv.to(u.m**3 / u.h).magnitude)
  with pytest.raises(Exception):
    module_under_test.KtoKv(15.0, diameter)

def test_head_pressure_and_velocity_flow_conversions_are_consistent() -> None:
  rho = 998 * u.kg / u.m**3
  head = 12 * u.m
  pressure = module_under_test.Htop(head, rho)
  head_back = module_under_test.ptoH(pressure, rho)

  flow = 9 * u.m**3 / u.h
  diameter = 100 * u.mm
  velocity = module_under_test.Qtov(flow, diameter)
  flow_back = module_under_test.vtoQ(velocity, diameter)

  assert head_back.to(u.m).magnitude == pytest.approx(head.to(u.m).magnitude)
  assert flow_back.to(u.m**3 / u.h).magnitude == pytest.approx(flow.to(u.m**3 / u.h).magnitude)

def test_ktoh_and_ktop_match_via_density_conversion() -> None:
  k_loss = 6.0
  velocity = 1.5 * u.m / u.s
  rho = 1000 * u.kg / u.m**3

  head = module_under_test.KtoH(k_loss, velocity)
  pressure_from_head = module_under_test.Htop(head, rho)
  pressure_direct = module_under_test.Ktop(k_loss, velocity, rho)

  assert pressure_from_head.to(u.bar).magnitude == pytest.approx(pressure_direct.to(u.bar).magnitude)

def test_calc_curve_filters_out_of_bounds_and_accepts_quantity_output() -> None:
  x_pts, y_pts = module_under_test.calcCurve(
    xb=0,
    xe=10,
    xn=6,
    yfun=lambda x: (x - 5) * u.m,
    yb=-2,
    ye=2,
  )

  assert list(x_pts) == [4.0, 6.0]
  assert list(y_pts) == [-1.0, 1.0]

def test_calc_orifice_branches_and_solver_arguments(monkeypatch) -> None:
  captured = {}

  def fake_solver(**kwargs):
    captured.clear()
    captured.update(kwargs)
    if kwargs.get('D2') is None:
      return 22 * u.mm
    if kwargs.get('P1') is None:
      return 2.4 * u.bar
    if kwargs.get('P2') is None:
      return 1.1 * u.bar
    if kwargs.get('m') is None:
      return 500 * u.kg / u.h
    return 42.0

  monkeypatch.setattr(module_under_test.fu, 'differential_pressure_meter_solver', fake_solver)

  out_orifice = module_under_test.calcOrifice(Q=3, d=50, Pin=2, Pout=1)
  out_pin = module_under_test.calcOrifice(Q=3, d=50, orifice=25, Pout=1)
  out_pout = module_under_test.calcOrifice(Q=3, d=50, orifice=25, Pin=2)
  out_q = module_under_test.calcOrifice(d=50, orifice=25, Pin=2, Pout=1)

  assert out_orifice.to(u.mm).magnitude == pytest.approx(22)
  assert out_pin.to(u.bar).magnitude == pytest.approx(2.4)
  assert out_pout.to(u.bar).magnitude == pytest.approx(1.1)
  assert out_q.to(u.m**3 / u.h).magnitude > 0.0
  assert captured['meter_type'] == 'ISO 5167 orifice'
  assert captured['taps'] in ['corner', '25 millimeter']

  with pytest.raises(ValueError, match='Name d not found'):
    module_under_test.calcOrifice(Q=3, orifice='corner', Pin=2, Pout=1)

def test_calc_orifice2_returns_diameter_from_newton_solution(monkeypatch) -> None:
  class DummyCircuit:
    rho = 1000 * u.kg / u.m**3
    mu = 1e-3 * u.Pa * u.s
    k = 1.4

    @staticmethod
    def calcH(_Q):
      return 10 * u.m

  monkeypatch.setattr(module_under_test.fu, 'P_from_head', lambda head, rho: 1.0 * u.bar)
  monkeypatch.setattr(module_under_test, 'newton', lambda func, x0, tol: 0.5)

  diameter = module_under_test.calcOrifice2(DummyCircuit(), 4 * u.m**3 / u.h, 80 * u.mm)

  assert diameter.to(u.mm).magnitude == pytest.approx(40.0)

Tests: test_wpoint

'''Behavioral unit tests for fluidsolve.wpoint.'''

# PYLINT DIRECTIVES
# pylint: disable=invalid-name,missing-function-docstring,missing-class-docstring,unused-argument,no-member

import inspect
import types
import pytest
import fluidsolve.wpoint as module_under_test

u = module_under_test.u

def test_module_importable() -> None:
  assert module_under_test is not None

@pytest.mark.parametrize('name', ['Wpoint', 'WpointDyn'])
def test_public_classes_exist(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert inspect.isclass(obj)

@pytest.mark.parametrize('name', ['calcOperatingPoint'])
def test_public_functions_are_callable(name: str) -> None:
  obj = getattr(module_under_test, name)
  assert callable(obj)

@pytest.mark.parametrize('name', ['Quantity', 'u'])
def test_public_variables_exist(name: str) -> None:
  assert hasattr(module_under_test, name)

class DummyComp(module_under_test.flsb.Comp_Base):
  _group = 'Test'
  _part = 'Dummy'

  def __init__(self, name: str='C', factor: float=1.0) -> None:
    super().__init__(name=name)
    self.factor = factor
    self.calls = []

  def calcH(self, Q, sense: int=1, pin: int=1, pout: int=2):
    self.calls.append((Q, sense, pin, pout))
    q_mag = Q.to(u.m**3 / u.h).magnitude if hasattr(Q, 'to') else float(Q)
    return self.factor * q_mag * sense * u.m

def test_wpoint_defaults_setters_and_magnitudes() -> None:
  point = module_under_test.Wpoint()

  assert point.name == ''
  assert point.Qmag == 0.0
  assert point.Hmag == 0.0

  point.name = 'WP1'
  point.Q = 3.5
  point.H = 8.0
  flow = point.Q
  head = point.H

  assert point.name == 'WP1'
  assert getattr(flow, 'to')(u.m**3 / u.h).magnitude == pytest.approx(3.5)
  assert getattr(head, 'to')(u.m).magnitude == pytest.approx(8.0)
  assert point.Qmag == pytest.approx(3.5)
  assert point.Hmag == pytest.approx(8.0)
  assert point.update() is point

def test_wpoint_string_and_repr_for_named_and_unnamed() -> None:
  unnamed = module_under_test.Wpoint(Q=2.0, H=4.0)
  named = module_under_test.Wpoint(name='NodeA', Q=2.0, H=4.0)

  assert str(unnamed).startswith('Pt: Q:')
  assert repr(unnamed).startswith('Pt: Q:')
  assert f'{unnamed:1}' == str(unnamed)
  assert 'Pt NodeA:' in str(named)
  assert f'{named:1}' == str(named)
  assert 'Pt NodeA:' in repr(named)

def test_calc_operating_point_returns_expected_values(monkeypatch) -> None:
  comp1 = DummyComp('C1', factor=-2.0)
  comp2 = DummyComp('C2', factor=3.0)

  monkeypatch.setattr(
    module_under_test,
    'root',
    lambda func, x0, method='hybr': types.SimpleNamespace(success=True, x=[2.5], message='ok', status=1),
  )

  q_op, h_op = module_under_test.calcOperatingPoint(comp1, comp2, guess=1.0)

  assert q_op.to(u.m**3 / u.h).magnitude == pytest.approx(2.5)
  assert h_op.to(u.m).magnitude == pytest.approx(7.5)
  assert hasattr(comp2.calls[-1][0], 'to')

def test_calc_operating_point_raises_when_solver_fails(monkeypatch) -> None:
  comp1 = DummyComp('C1', factor=-2.0)
  comp2 = DummyComp('C2', factor=3.0)

  monkeypatch.setattr(
    module_under_test,
    'root',
    lambda func, x0, method='hybr': types.SimpleNamespace(success=False, x=[1.0], message='no convergence', status=4),
  )

  with pytest.warns(RuntimeWarning, match='did not converge|no convergence'):
    q_op, h_op = module_under_test.calcOperatingPoint(comp1, comp2)

  assert q_op.to(u.m**3 / u.h).magnitude == 0.0
  assert h_op.to(u.m).magnitude == 0.0

def test_wpointdyn_uses_components_and_updates_from_operating_point(monkeypatch) -> None:
  comp1 = DummyComp('C1', factor=-1.0)
  comp2 = DummyComp('C2', factor=2.0)

  monkeypatch.setattr(
    module_under_test,
    'calcOperatingPoint',
    lambda s1, s2, guess: (4.0 * u.m**3 / u.h, 6.0 * u.m),
  )

  point = module_under_test.WpointDyn(name='dyn', s1=comp1, s2=comp2, guess=10)

  assert point.name == 'dyn'
  assert point.Qmag == pytest.approx(4.0)
  assert point.Hmag == pytest.approx(6.0)

  point.update()
  assert point.Qmag == pytest.approx(4.0)
  assert point.Hmag == pytest.approx(6.0)

def test_wpointdyn_without_components_keeps_initial_values() -> None:
  with pytest.raises(ValueError, match='argument s1 not of type'):
    module_under_test.WpointDyn(name='dyn', Q=1.0, H=2.0)