Fixes tests (#3)

Fixes how to check identity of the outputs from functions.

Author: msaito8623

tests/test_ldl.py

@@ -88,30 +88,30 @@ def test_initialize_with_matrices ():
     assert all(pd.Series(ldl.__dict__.keys()) == pd.Series(['words', 'cmat',
         'smat', 'fmat', 'gmat', 'vmat', 'chat', 'shat']))
     assert all(pd.Series(ldl.words) == pd.Series(['ban', 'banban']))
-    assert ldl.cmat.identical(cmat)
-    assert ldl.smat.identical(smat)
-    assert ldl.fmat.identical(fmat)
-    assert ldl.gmat.identical(gmat)
-    assert ldl.vmat.identical(vmat)
-    assert ldl.shat.identical(shat)
-    assert ldl.chat.identical(chat)
+    xr.testing.assert_allclose(ldl.cmat, cmat)
+    xr.testing.assert_allclose(ldl.smat, smat)
+    xr.testing.assert_allclose(ldl.fmat, fmat)
+    xr.testing.assert_allclose(ldl.gmat, gmat)
+    xr.testing.assert_allclose(ldl.vmat, vmat)
+    xr.testing.assert_allclose(ldl.shat, shat)
+    xr.testing.assert_allclose(ldl.chat, chat)
 
 def test_gen_cmat ():
     ldl = LDL()
     ldl.gen_cmat(words=words)
-    assert ldl.cmat.identical(cmat)
+    xr.testing.assert_allclose(ldl.cmat, cmat)
 
 def test_gen_cmat_withfreq ():
     ldl = LDL()
     ldl.gen_cmat(words=words, freqs=freqs)
-    assert ldl.cmat.identical(cmatfreq)
+    xr.testing.assert_allclose(ldl.cmat, cmatfreq)
 
 def test_gen_smat ():
     ldl = LDL()
     ldl.gen_smat(embed_or_df=semdf, words=words)
-    assert ldl.smat.identical(smat)
+    xr.testing.assert_allclose(ldl.smat, smat)
 
 def test_gen_smat_withfreq ():
     ldl = LDL()
     ldl.gen_smat(embed_or_df=semdf, words=words, freqs=freqs)
-    assert ldl.smat.identical(smatfreq)
+    xr.testing.assert_allclose(ldl.smat, smatfreq)

tests/test_mapping.py

@@ -90,9 +90,9 @@ def test_gen_smat_sim (ind, form, sep, dim_size, mn, sd, incl, diff, seed):
         _smat = xr.open_dataarray(_smat)
         smat = pm.gen_smat_sim(infl, form, sep, dim_size, mn, sd, incl, diff, seed)
         if seed is None:
-            assert not smat.identical(_smat)
+            assert not smat.round(10).identical(_smat.round(10))
         else:
-            assert smat.identical(_smat)
+            xr.testing.assert_allclose(smat, _smat)
 
 
 def test_gen_fmat():
@@ -101,15 +101,15 @@ def test_gen_fmat():
     fmat = pm.gen_fmat(cmat, smat)
     _fmat = '{}/fmat.nc'.format(RESOURCES)
     _fmat = xr.open_dataarray(_fmat)
-    assert fmat.identical(_fmat)
+    xr.testing.assert_allclose(fmat, _fmat)
 
 def test_gen_gmat():
     cmat = pm.gen_cmat(infl.word, gram=3, count=False, noise=0)
     smat = pm.gen_smat_sim(infl, form='word', sep='/', dim_size=5, seed=10)
     gmat = pm.gen_gmat(cmat, smat)
     _gmat = '{}/gmat.nc'.format(RESOURCES)
     _gmat = xr.open_dataarray(_gmat)
-    assert gmat.identical(_gmat)
+    xr.testing.assert_allclose(gmat, _gmat)
 
 cmat = pm.gen_cmat(infl.word, gram=3, count=False, noise=0)
 smat = pm.gen_smat_sim(infl, form='word', sep='/', dim_size=5, seed=10)
@@ -133,7 +133,7 @@ def test_gen_shat (ind, cmat, fmat, smat, hmat):
         if ind==3: # Rounding due to rounding errors when producing hmat.
             shat  = shat.round(10)
             _shat = _shat.round(10)
-        assert shat.identical(_shat)
+        xr.testing.assert_allclose(shat, _shat)
 
 
 gmat = pm.gen_gmat(cmat, smat)
@@ -156,7 +156,7 @@ def test_gen_chat (ind, smat, gmat, cmat, hmat):
         if ind==3: # Rounding due to rounding errors when producing hmat.
             chat  = chat.round(10)
             _chat = _chat.round(10)
-        assert chat.identical(_chat)
+        xr.testing.assert_allclose(chat, _chat)
 
 def test_update_weight_matrix ():
     w = np.zeros((4,2))
@@ -215,7 +215,7 @@ def test_incremental_learning_byind01 ():
     fmat0_cues_values = ['#a', 'a#', 'an', 'n#']
     fmat0_feature_values = ['Word:a', 'Word:an']
     fmat0 = xr.DataArray(np.array(fmat0_values).reshape(fmat0_shape), dims=fmat0_dims, coords={'cues':fmat0_cues_values, 'feature':fmat0_feature_values})
-    assert fmat_test.identical(fmat0)
+    xr.testing.assert_allclose(fmat_test, fmat0)
 
 def test_incremental_learning_byind02 ():
     cmat  = pm.gen_cmat(['a','an'], gram=2)

tests/test_measures.py

@@ -50,8 +50,8 @@ def test_semantic_support (ind, word, cue):
             assert e_info == 'xxx'
     else:
         sp = lmea.semantic_support(word, cue, chat)
-        _sp = ["0.0000000000", "1.0000000000", "None", "1.0000000000", "1.0000000000", "None", "None", "None", "None"]
-        assert '{:12.10f}'.format(sp) == _sp[ind]
+        _sp = [0, 1, "None", 1, 1, "None", "None", "None", "None"]
+        assert round(sp,10) == _sp[ind]
 
 pars_semantic_support_word = [ (i,j) for i,j in enumerate(wrd) ]
 @pytest.mark.parametrize('ind, word', pars_semantic_support_word)