minor test adjusts

test/test_dflike__setget__.py

@@ -4,26 +4,19 @@ import pytest
 
 
 def _test(res, exp):
+
     if isinstance(exp, pd.DataFrame):
-        assert isinstance(res, DictOfSeries)
-
-        if res.empty:
-            for c in exp:
-                assert exp[c].dropna().empty
-            return
-
-        assert (res.columns == exp.columns).all()
-        for c in exp:
-            l = res[c]
-            r = exp[c].dropna()
-            assert isinstance(l, pd.Series)
-            assert isinstance(r, pd.Series)
-            assert (l == r).all()
+        t = dios_eq_df(res, exp, with_msg=True)
+        assert t[0], t[1]
+
     else:
         assert type(exp) == type(res)
 
         if isinstance(exp, pd.Series):
-            assert (res == exp.dropna()).all()
+            t = diosSeries_eq_dfSeries(res, exp, with_msg=True)
+            assert t[0], t[1]
+
+        # scalars
         else:
             assert res == exp
 

test/test_setup.py

@@ -32,6 +32,104 @@ def dios_():
     return dios__().copy()
 
 
+def __fail(msg, with_msg, raiseassert):
+    if raiseassert:
+        if with_msg:
+            assert False, msg
+        assert False
+    if with_msg:
+        return False, msg
+    return False
+
+
+def diosSeries_eq_dfSeries(diosser, dfser, with_msg=False, raiseassert=False):
+    def fail(msg):
+        return __fail(msg, with_msg, raiseassert)
+
+    assert isinstance(dfser, pd.Series)
+    assert isinstance(diosser, pd.Series)
+
+    s1, s2 = dfser, diosser
+    if s1.empty and not s2.empty:
+        return fail(f"df-ser is empty, but dios-ser == {s2}")
+
+    # compare series
+    for i in s1.index:
+        exp = s1.loc[i]
+
+        # Normally df-nans, from selecting are just not present values
+        # in a dios. But if a Nan was inserted in the dios it is a valid
+        # value, so we firstly try to access the value.
+        try:
+            val = s2.loc[i]
+        except KeyError:
+            if np.isnan(exp):
+                continue
+            else:
+                return fail(f"df-ser.loc[{i}] == {exp}, but dios-ser.loc[{i}] does not exist")
+
+        if np.isnan(exp) and not np.isnan(val):
+            return fail(f"df-ser.loc[{i}] == {exp}, but dios-ser.loc[{i}] == {val}")
+
+        if exp != val:
+            return fail(f"df-ser.loc[{i}] == {exp}, but dios-ser.loc[{i}] == {val}")
+
+    return True, "equal" if with_msg else True
+
+
+def dios_eq_df(dios, df, dios_dropped_empty_colums=False, with_msg=False, raiseassert=False):
+    def fail(msg):
+        return __fail(msg, with_msg, raiseassert)
+
+    assert isinstance(df, pd.DataFrame)
+    assert isinstance(dios, DictOfSeries)
+
+    # check: dios has not more/other cols than df
+    notmore = [c for c in dios if c not in df]
+    if notmore:
+        return fail(f"dios has more columns, than df: {notmore}")
+
+    miss = [c for c in df if c not in dios]
+    # check: df has empty cols, if dios has missing cols
+    if miss:
+        if dios_dropped_empty_colums:
+            for c in miss:
+                if not df[c].dropna().empty:
+                    return fail(f"dios missing a column: {c}")
+        else:
+            return fail(f"dios missing columns: {miss}")
+
+    for c in df:
+        s1 = df[c]
+        s2 = dios[c]
+
+        if s1.empty and not s2.empty:
+            return fail(f"df[{c}] is empty, but dios[{c}] == {s2}")
+
+        # compare series
+        for i in s1.index:
+            exp = s1.loc[i]
+
+            # Normally df-nans, from selecting are just not present values
+            # in a dios. But if a Nan was inserted in the dios it is a valid
+            # value, so we firstly try to access the value.
+            try:
+                val = s2.loc[i]
+            except KeyError:
+                if np.isnan(exp):
+                    continue
+                else:
+                    return fail(f"df.loc[{i}, {c}] == {exp}, but dios.loc[{i}, {c}] does not exist")
+
+            if np.isnan(exp) and not np.isnan(val):
+                return fail(f"df.loc[{i}, {c}] == {exp}, but dios.loc[{i}, {c}] == {val}")
+
+            if exp != val:
+                return fail(f"df.loc[{i}, {c}] == {exp}, but dios.loc[{i}, {c}] == {val}")
+
+    return True, "equal" if with_msg else True
+
+
 BLIST = [True, False, False, False, True] * 2
 
 LISTIDXER = [['a'], ['a', 'c'], pd.Series(['a', 'c'])]
@@ -42,14 +140,14 @@ EMPTYIDEXER = [[], pd.Series(), slice(3, 3), slice(3, -1), pd.DataFrame(), []]
 
 INDEXERS = LISTIDXER + BOOLIDXER + SLICEIDXER + MULTIIDXER + EMPTYIDEXER
 
-LOC_L = [slice(None), slice(2, 8), pd.Series(BLIST), BLIST, [6,5], 2]
-LOC_R = [slice(None), slice('a', 'c'), pd.Series([False,False,True,False], index=list("abcd")),
-         [False,False,True,False], "a"] + LISTIDXER
+LOC_L = [slice(None), slice(2, 8), pd.Series(BLIST), BLIST, [6, 5], 2]
+LOC_R = [slice(None), slice('a', 'c'), pd.Series([False, False, True, False], index=list("abcd")),
+         [False, False, True, False], "a"] + LISTIDXER
 
-ILIST = [[0], [1,3], 2]
+ILIST = [[0], [1, 3], 2]
 IEMPTY = [[], slice(3, 3), slice(3, -1), []]
 ILOC_L = [slice(None), slice(2, 8), BLIST, ] + ILIST
-ILOC_R = [slice(None), slice(1, 3), [False,False,True,False], ] + ILIST
+ILOC_R = [slice(None), slice(1, 3), [False, False, True, False], ] + ILIST
 
 FAIL_INDEXERS = [['z'], ['a', 'z'], pd.Series(['a', 'z']), BLIST, pd.DataFrame(dict(a=[1, 2, 3]))]