inewave 1.7.5__py3-none-any.whl → 1.8.1__py3-none-any.whl

tests/nwlistop/test_qvertuh.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.qvertuh import Qvertuh
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vertuh import MockVertuh
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_qvertuh():
+    m: MagicMock = mock_open(read_data="".join(MockVertuh))
+    with patch("builtins.open", m):
+        n = Qvertuh.read(ARQ_TESTE)
+        assert n.usina is not None
+        assert n.usina == "ESPORA"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_qvertuh():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Qvertuh.read(ARQ_TESTE)
+        assert n.usina is None
+        assert n.valores is None
+
+
+def test_eq_qvertuh():
+    m: MagicMock = mock_open(read_data="".join(MockVertuh))
+    with patch("builtins.open", m):
+        n1 = Qvertuh.read(ARQ_TESTE)
+        n2 = Qvertuh.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_valor_agua.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.valor_agua import ValorAgua
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vagua import MockVagua
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_valor_agua():
+    m: MagicMock = mock_open(read_data="".join(MockVagua))
+    with patch("builtins.open", m):
+        n = ValorAgua.read(ARQ_TESTE)
+        assert n.ree is not None
+        assert n.ree == "SUDESTE"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2022, 1, 1)
+        assert n.valores.iloc[-1, -1] == -0.09
+
+
+def test_atributos_nao_encontrados_valor_agua():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ValorAgua.read(ARQ_TESTE)
+        assert n.ree is None
+        assert n.valores is None
+
+
+def test_eq_valor_agua():
+    m: MagicMock = mock_open(read_data="".join(MockVagua))
+    with patch("builtins.open", m):
+        n1 = ValorAgua.read(ARQ_TESTE)
+        n2 = ValorAgua.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_eletricasin.py

@@ -0,0 +1,37 @@
+from inewave.nwlistop.viol_eletricasin import ViolEletricasin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.deletricas import MockDeletricas
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_eletricasin():
+    m: MagicMock = mock_open(read_data="".join(MockDeletricas))
+    with patch("builtins.open", m):
+        n = ViolEletricasin.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2023, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_eletricasin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolEletricasin.read(ARQ_TESTE)
+        assert n.valores is None
+
+
+def test_eq_viol_eletricasin():
+    m: MagicMock = mock_open(read_data="".join(MockDeletricas))
+    with patch("builtins.open", m):
+        n1 = ViolEletricasin.read(ARQ_TESTE)
+        n2 = ViolEletricasin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_evmin.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.viol_evmin import ViolEvmin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vevmin import MockVevmin
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_evmin():
+    m: MagicMock = mock_open(read_data="".join(MockVevmin))
+    with patch("builtins.open", m):
+        n = ViolEvmin.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+        assert n.ree is not None
+        assert n.ree == "SUDESTE"
+
+
+def test_atributos_nao_encontrados_viol_evmin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolEvmin.read(ARQ_TESTE)
+        assert n.valores is None
+        assert n.ree is None
+
+
+def test_eq_viol_evmin():
+    m: MagicMock = mock_open(read_data="".join(MockVevmin))
+    with patch("builtins.open", m):
+        n1 = ViolEvmin.read(ARQ_TESTE)
+        n2 = ViolEvmin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_evminm.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.viol_evminm import ViolEvminm
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vevminm import MockVevminm
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_evminm():
+    m: MagicMock = mock_open(read_data="".join(MockVevminm))
+    with patch("builtins.open", m):
+        n = ViolEvminm.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+        assert n.submercado is not None
+        assert n.submercado == "SUDESTE"
+
+
+def test_atributos_nao_encontrados_viol_evminm():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolEvminm.read(ARQ_TESTE)
+        assert n.valores is None
+        assert n.submercado is None
+
+
+def test_eq_viol_evminm():
+    m: MagicMock = mock_open(read_data="".join(MockVevminm))
+    with patch("builtins.open", m):
+        n1 = ViolEvminm.read(ARQ_TESTE)
+        n2 = ViolEvminm.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_evminsin.py

@@ -0,0 +1,37 @@
+from inewave.nwlistop.viol_evminsin import ViolEvminsin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vevminsin import MockVevminSIN
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_evminsin():
+    m: MagicMock = mock_open(read_data="".join(MockVevminSIN))
+    with patch("builtins.open", m):
+        n = ViolEvminsin.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_evminsin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolEvminsin.read(ARQ_TESTE)
+        assert n.valores is None
+
+
+def test_eq_viol_evminsin():
+    m: MagicMock = mock_open(read_data="".join(MockVevminSIN))
+    with patch("builtins.open", m):
+        n1 = ViolEvminsin.read(ARQ_TESTE)
+        n2 = ViolEvminsin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_fpha.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.viol_fpha import ViolFpha
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.viol_fpha import MockViolFpha
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_fpha():
+    m: MagicMock = mock_open(read_data="".join(MockViolFpha))
+    with patch("builtins.open", m):
+        n = ViolFpha.read(ARQ_TESTE)
+        assert n.usina is not None
+        assert n.usina == "CAMARGOS"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2021, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_fpha():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolFpha.read(ARQ_TESTE)
+        assert n.usina is None
+        assert n.valores is None
+
+
+def test_eq_viol_fpha():
+    m: MagicMock = mock_open(read_data="".join(MockViolFpha))
+    with patch("builtins.open", m):
+        n1 = ViolFpha.read(ARQ_TESTE)
+        n2 = ViolFpha.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_ghmin.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.viol_ghmin import ViolGhmin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vghmin import MockVghmin
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_ghmin():
+    m: MagicMock = mock_open(read_data="".join(MockVghmin))
+    with patch("builtins.open", m):
+        n = ViolGhmin.read(ARQ_TESTE)
+        assert n.ree is not None
+        assert n.ree == "SUDESTE"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_ghmin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolGhmin.read(ARQ_TESTE)
+        assert n.ree is None
+        assert n.valores is None
+
+
+def test_eq_viol_ghmin():
+    m: MagicMock = mock_open(read_data="".join(MockVghmin))
+    with patch("builtins.open", m):
+        n1 = ViolGhmin.read(ARQ_TESTE)
+        n2 = ViolGhmin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_ghminm.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.viol_ghminm import ViolGhminm
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vghminm import MockVghminm
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_ghminm():
+    m: MagicMock = mock_open(read_data="".join(MockVghminm))
+    with patch("builtins.open", m):
+        n = ViolGhminm.read(ARQ_TESTE)
+        assert n.submercado is not None
+        assert n.submercado == "SUDESTE"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_ghminm():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolGhminm.read(ARQ_TESTE)
+        assert n.submercado is None
+        assert n.valores is None
+
+
+def test_eq_viol_ghminm():
+    m: MagicMock = mock_open(read_data="".join(MockVghminm))
+    with patch("builtins.open", m):
+        n1 = ViolGhminm.read(ARQ_TESTE)
+        n2 = ViolGhminm.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_ghminsin.py

@@ -0,0 +1,37 @@
+from inewave.nwlistop.viol_ghminsin import ViolGhminsin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vghminsin import MockVghminSIN
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_ghminsin():
+    m: MagicMock = mock_open(read_data="".join(MockVghminSIN))
+    with patch("builtins.open", m):
+        n = ViolGhminsin.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_ghminsin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolGhminsin.read(ARQ_TESTE)
+        assert n.valores is None
+
+
+def test_eq_viol_ghminsin():
+    m: MagicMock = mock_open(read_data="".join(MockVghminSIN))
+    with patch("builtins.open", m):
+        n1 = ViolGhminsin.read(ARQ_TESTE)
+        n2 = ViolGhminsin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_ghminuh.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.viol_ghminuh import ViolGhminuh
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vghminuh import MockVghminUH
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_ghminuh():
+    m: MagicMock = mock_open(read_data="".join(MockVghminUH))
+    with patch("builtins.open", m):
+        n = ViolGhminuh.read(ARQ_TESTE)
+        assert n.usina is not None
+        assert n.usina == "CAMARGOS"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_ghminuh():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolGhminuh.read(ARQ_TESTE)
+        assert n.usina is None
+        assert n.valores is None
+
+
+def test_eq_viol_ghminuh():
+    m: MagicMock = mock_open(read_data="".join(MockVghminUH))
+    with patch("builtins.open", m):
+        n1 = ViolGhminuh.read(ARQ_TESTE)
+        n2 = ViolGhminuh.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_lpp_dfmax.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.viol_lpp_dfmax import ViolLppDfmax
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.dlppdfmax import MockDLPPdfmax
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_lpp_dfmax():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPdfmax))
+    with patch("builtins.open", m):
+        n = ViolLppDfmax.read(ARQ_TESTE)
+        assert n.ree is not None
+        assert n.ree == "SUDESTE"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_lpp_dfmax():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolLppDfmax.read(ARQ_TESTE)
+        assert n.ree is None
+        assert n.valores is None
+
+
+def test_eq_viol_lpp_dfmax():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPdfmax))
+    with patch("builtins.open", m):
+        n1 = ViolLppDfmax.read(ARQ_TESTE)
+        n2 = ViolLppDfmax.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_lpp_dfmaxm.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.viol_lpp_dfmaxm import ViolLppDfmaxm
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.dlppdfmaxm import MockDLPPdfmaxm
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_lpp_dfmaxm():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPdfmaxm))
+    with patch("builtins.open", m):
+        n = ViolLppDfmaxm.read(ARQ_TESTE)
+        assert n.submercado is not None
+        assert n.submercado == "SUDESTE"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_lpp_dfmaxm():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolLppDfmaxm.read(ARQ_TESTE)
+        assert n.submercado is None
+        assert n.valores is None
+
+
+def test_eq_viol_lpp_dfmaxm():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPdfmaxm))
+    with patch("builtins.open", m):
+        n1 = ViolLppDfmaxm.read(ARQ_TESTE)
+        n2 = ViolLppDfmaxm.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_lpp_dfmaxsin.py

@@ -0,0 +1,37 @@
+from inewave.nwlistop.viol_lpp_dfmaxsin import ViolLppDfmaxsin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.dlppdfmaxs import MockDLPPdfmaxs
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_lpp_dfmaxsin():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPdfmaxs))
+    with patch("builtins.open", m):
+        n = ViolLppDfmaxsin.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_lpp_dfmaxsin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolLppDfmaxsin.read(ARQ_TESTE)
+        assert n.valores is None
+
+
+def test_eq_viol_lpp_dfmaxsin():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPdfmaxs))
+    with patch("builtins.open", m):
+        n1 = ViolLppDfmaxsin.read(ARQ_TESTE)
+        n2 = ViolLppDfmaxsin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_lpp_tbmax.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.viol_lpp_tbmax import ViolLppTbmax
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.dlpptbmax import MockDLPPtbmax
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_lpp_tbmax():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPtbmax))
+    with patch("builtins.open", m):
+        n = ViolLppTbmax.read(ARQ_TESTE)
+        assert n.ree is not None
+        assert n.ree == "SUDESTE"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_lpp_tbmax():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolLppTbmax.read(ARQ_TESTE)
+        assert n.ree is None
+        assert n.valores is None
+
+
+def test_eq_viol_lpp_tbmax():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPtbmax))
+    with patch("builtins.open", m):
+        n1 = ViolLppTbmax.read(ARQ_TESTE)
+        n2 = ViolLppTbmax.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_lpp_tbmaxm.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.viol_lpp_tbmaxm import ViolLppTbmaxm
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.dlpptbmaxm import MockDLPPtbmaxm
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_lpp_tbmaxm():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPtbmaxm))
+    with patch("builtins.open", m):
+        n = ViolLppTbmaxm.read(ARQ_TESTE)
+        assert n.submercado is not None
+        assert n.submercado == "SUDESTE"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_lpp_tbmaxm():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolLppTbmaxm.read(ARQ_TESTE)
+        assert n.submercado is None
+        assert n.valores is None
+
+
+def test_eq_viol_lpp_tbmaxm():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPtbmaxm))
+    with patch("builtins.open", m):
+        n1 = ViolLppTbmaxm.read(ARQ_TESTE)
+        n2 = ViolLppTbmaxm.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_viol_lpp_tbmaxsin.py

@@ -0,0 +1,37 @@
+from inewave.nwlistop.viol_lpp_tbmaxsin import ViolLppTbmaxsin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.dlpptbmaxs import MockDLPPtbmaxs
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_viol_lpp_tbmaxsin():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPtbmaxs))
+    with patch("builtins.open", m):
+        n = ViolLppTbmaxsin.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_viol_lpp_tbmaxsin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = ViolLppTbmaxsin.read(ARQ_TESTE)
+        assert n.valores is None
+
+
+def test_eq_viol_lpp_tbmaxsin():
+    m: MagicMock = mock_open(read_data="".join(MockDLPPtbmaxs))
+    with patch("builtins.open", m):
+        n1 = ViolLppTbmaxsin.read(ARQ_TESTE)
+        n2 = ViolLppTbmaxsin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.