klongpy 0.6.9__py3-none-any.whl → 0.7.1__py3-none-any.whl

tests/test_interop.py

@@ -1,180 +0,0 @@
-import random
-import unittest
-from datetime import datetime
-
-from utils import *
-
-from klongpy import KlongInterpreter
-
-
-class TestPythonInterop(unittest.TestCase):
-
-    def test_python_lambda_as_argument(self):
-        """
-        Test that a python lambda can be passed as an argument to a klong function.
-        """
-        klong = KlongInterpreter()
-        klong['fn'] = lambda x: x+10
-        klong('foo::{x(2)}')
-        r = klong('foo(fn)')
-        self.assertEqual(r, 12)
-
-    def test_ext_var(self):
-        klong = KlongInterpreter()
-        x = random.random()
-        klong['foo'] = x
-        self.assertEqual(klong['foo'],x)
-        # test reassignment
-        x = random.random()
-        x = [x]
-        klong['foo'] = x
-        self.assertTrue(kg_equal(klong['foo'],x))
-
-    def test_del_var(self):
-        klong = KlongInterpreter()
-        with self.assertRaises(KeyError):
-            del klong['foo']
-        klong['foo'] = 1
-        del klong['foo']
-        with self.assertRaises(KeyError):
-            del klong['foo']
-
-    def test_python_lambda(self):
-        klong = KlongInterpreter()
-        klong['fn'] = lambda x: x+10
-        self.assertEqual(klong('fn(2)'), 12)
-
-    def test_call_klong_python_lambda(self):
-        klong = KlongInterpreter()
-        klong['fn'] = lambda x: x+10
-        fn = klong['fn']
-        self.assertEqual(fn(1),11)
-
-    def test_invalid_call_klong_python_lambda(self):
-        klong = KlongInterpreter()
-        klong['fn'] = lambda x: x+10
-        fn = klong['fn']
-        with self.assertRaises(RuntimeError):
-            self.assertEqual(fn(1,2),11)
-
-    def test_call_klong_fn_with_scalar(self):
-        klong = KlongInterpreter()
-        klong('fn::{x+10}')
-        r = klong['fn'](2)
-        self.assertEqual(r, 12)
-
-    def test_call_klong_fn_with_multiple_scalars(self):
-        klong = KlongInterpreter()
-        klong = KlongInterpreter()
-        klong("fn::{(x*1000) + y - z}")
-        r = klong['fn'](3, 10, 20)
-        self.assertEqual(r, 2990)
-
-    def test_call_klong_fn_with_array(self):
-        klong = KlongInterpreter()
-        klong("fn::{{x+10}'x}")
-        r = klong['fn']([2])
-        self.assertTrue(kg_equal(r, [12]))
-
-    def test_datetime_parsing_example(self):
-        klong = KlongInterpreter()
-        klong['strptime'] = lambda x: datetime.strptime(x, "%d %B, %Y")
-        r = klong('a::strptime("21 June, 2018")')
-        self.assertEqual(r, datetime(2018, 6, 21, 0, 0))
-        r = klong['a']
-        self.assertEqual(r, datetime(2018, 6, 21, 0, 0))
-        r = klong('d:::{};d,"timestamp",a')
-        self.assertEqual(r, {'timestamp': datetime(2018, 6, 21, 0, 0)})
-
-    def test_datetime_parsing_example_one_call(self):
-        # run everything in one go
-        klong = KlongInterpreter()
-        klong['strptime'] = lambda x: datetime.strptime(x, "%d %B, %Y")
-        r = klong("""a::strptime("21 June, 2018");d:::{};d,"timestamp",a""")
-        self.assertEqual(r, {'timestamp': datetime(2018, 6, 21, 0, 0)})
-        r = klong['a']
-        self.assertEqual(r, datetime(2018, 6, 21, 0, 0))
-
-    def test_callback_into_assertion(self):
-        def assert_date(x):
-            self.assertEqual(x, {'timestamp': datetime(2018, 6, 21, 0, 0)})
-            return 42
-        klong = KlongInterpreter()
-        klong['strptime'] = lambda x: datetime.strptime(x, "%d %B, %Y")
-        klong['assert'] = assert_date
-        r = klong("""a::strptime("21 June, 2018");d:::{};d,"timestamp",a;assert(d)""")
-        self.assertEqual(r, 42)
-
-    def test_lambda_nilad(self):
-        klong = KlongInterpreter()
-        klong['f'] = lambda: 1000
-        r = klong('f()')
-        self.assertEqual(r, 1000)
-
-    def test_lambda_monad(self):
-        klong = KlongInterpreter()
-        klong['f'] = lambda x: x*1000
-        r = klong('f(3)')
-        self.assertEqual(r, 3000)
-
-    def test_lambda_dyad(self):
-        klong = KlongInterpreter()
-        klong['f'] = lambda x, y: x*1000 + y
-        r = klong('f(3;10)')
-        self.assertEqual(r, 3 * 1000 + 10)
-
-    def test_lambda_triad(self):
-        klong = KlongInterpreter()
-        klong['f'] = lambda x, y, z: x*1000 + y - z
-        r = klong('f(3; 10; 20)')
-        self.assertEqual(r, 3 * 1000 + 10 - 20)
-
-    def test_lambda_projection(self):
-        klong = KlongInterpreter()
-        klong['f'] = lambda x, y, z: ((x*1000) + y) - z
-        klong("g::f(3;;)") # TODO: can we make the y and z vals implied None?
-        r = klong('g(10;20)')
-        self.assertEqual(r, ((3 * 1000) + 10) - 20)
-        klong("h::g(10;)")
-        r = klong('h(20)')
-        self.assertEqual(r, ((3 * 1000) + 10) - 20)
-
-    def test_setitem(self):
-        klong = KlongInterpreter()
-        klong['A'] = 1
-        r = klong("A")
-        self.assertEqual(r, 1)
-        self.assertEqual(klong['A'], 1)
-
-    def test_define_simple(self):
-        klong = KlongInterpreter()
-        r = klong("A::1; A")
-        self.assertEqual(r, 1)
-        self.assertEqual(klong['A'], 1)
-
-    def test_define_reassign(self):
-        klong = KlongInterpreter()
-        klong('A::1')
-        r = klong('A')
-        self.assertEqual(r, 1)
-        klong('A::2')
-        r = klong('A')
-        self.assertEqual(r, 2)
-
-    def test_avg_mixed(self):
-        data = np.random.rand(10**5)
-        klong = KlongInterpreter()
-        klong('avg::{(+/x)%#x}')
-        klong['data'] = data
-        start = time.perf_counter_ns()
-        r = klong('avg(data)')
-        stop = time.perf_counter_ns()
-        # print((stop - start) / (10**9))
-        self.assertEqual(r, np.average(data))
-
-    def test_join_np_array_and_list(self):
-        klong = KlongInterpreter()
-        klong("A::[];A::A,:{};A::A,:{}")
-        klong['B'] = [{}, {}, {}]
-        r = klong("A,B")
-        self.assertTrue(kg_equal(r, [{}, {}, {}, {}, {}]))

tests/test_kg_asarray.py

@@ -1,94 +0,0 @@
-import unittest
-
-import numpy as np
-
-from klongpy.core import kg_asarray, KGChar, KGSym
-
-
-class TestKGAsArray(unittest.TestCase):
-
-    def test_kg_asarray_scalar_int(self):
-        x = 42
-        arr = kg_asarray(x)
-        assert np.isarray(arr)
-        assert arr.dtype == int
-        assert arr.shape == ()
-        assert arr.item() == 42
-
-    def test_kg_asarray_scalar_float(self):
-        x = 3.14
-        arr = kg_asarray(x)
-        assert np.isarray(arr)
-        assert arr.dtype == float
-        assert arr.item() == 3.14
-
-    def test_kg_asarray_empty_list(self):
-        x = []
-        arr = kg_asarray(x)
-        assert np.isarray(arr)
-        assert arr.dtype == float  # default dtype for empty list
-        assert arr.size == 0
-
-    def test_kg_asarray_string(self):
-        s = "hello"
-        arr = kg_asarray(s)
-        assert np.isarray(arr)
-        assert arr.dtype == object  # assuming KGChar is object dtype
-        assert "".join(arr) == "hello"
-
-    def test_kg_asarray_list_of_ints(self):
-        x = [1, 2, 3]
-        arr = kg_asarray(x)
-        assert np.isarray(arr)
-        assert arr.dtype == int
-        assert np.array_equal(arr, [1, 2, 3])
-
-    def test_kg_asarray_nested_list_uniform(self):
-        x = [[1, 2], [3, 4]]
-        arr = kg_asarray(x)
-        assert np.isarray(arr)
-        assert arr.shape == (2,2)
-        assert arr.dtype == int
-        assert np.array_equal(arr, [[1,2],[3,4]])
-
-    @unittest.skip("what is the expected behavior for this case?")
-    def test_kg_asarray_nested_list_heterogeneous(self):
-        # should embedded strings be expanded to individual characters?
-        x = [[1, 2], "abc", [3.14, None]]
-        arr = kg_asarray(x)
-        assert np.isarray(arr)
-        # Because of heterogeneous data, dtype should be object.
-        assert arr.dtype == object
-        # Check that sub-elements are arrays
-        assert np.isarray(arr[0])
-        assert np.isarray(arr[1])
-        assert np.isarray(arr[2])
-
-    def test_kg_asarray_already_array(self):
-        x = np.array([1, 2, 3])
-        arr = kg_asarray(x)
-        # Should return as-is because already suitable dtype
-        assert arr is x
-
-    def test_kg_asarray_jagged_list(self):
-        x = [[1, 2, 3], [4, 5], [6]]
-        arr = kg_asarray(x)
-        assert np.isarray(arr)
-        # Jagged => object dtype
-        assert arr.dtype == object
-        # Each element should be an array
-        assert all(np.isarray(e) for e in arr)
-        assert np.array_equal(arr[0], [1, 2, 3])
-        assert np.array_equal(arr[1], [4, 5])
-        assert np.array_equal(arr[2], [6])
-
-
-    def benchmark_kg_asarray(self):
-        import timeit
-        x = [[1, 2], [3, 4]]
-        print(timeit.timeit(lambda: kg_asarray(x), number=100_000))
-
-
-if __name__ == "__main__":
-    # run the benchmark
-    TestKGAsArray().benchmark_kg_asarray()

tests/test_kgtests.py

@@ -1,65 +0,0 @@
-import glob
-import math
-import os
-import unittest
-
-from utils import *
-
-
-class TestKgTests(unittest.TestCase):
-
-    def test_known_failure(self):
-        klong = KlongInterpreter()
-        klong['fullpath'] = "tests/kgtests/known_failure.kg"
-        klong('.l("tests/kgtests/runner.kg")')
-        self.assertEqual(klong['err'], 1)
-
-    def eval_file_by_lines(self, fname):
-        """
-        Test the suite file line by line using our own t()
-        """
-        klong = create_test_klong()
-        with open(fname, "r") as f:
-            skip_header = True
-            i = 0
-            for r in f.readlines():
-                if skip_header:
-                    if r.startswith("t::"):
-                        skip_header = False
-                    else:
-                        continue
-                r = r.strip()
-                if len(r) == 0:
-                    continue
-                i += 1
-                klong.exec(r)
-                self.assertEqual(klong['err'],0)
-            print(f"executed {i} lines")
-
-
-    def test_kgtests(self):
-        """
-        Recursively run all tests under the kgtests folder that begin with "test" and end with ".kg".
-        """
-        ran_tests = False
-        root_dir = os.path.join(os.getcwd(), "tests", "kgtests")
-
-        for dirpath, _, filenames in os.walk(root_dir):
-            for fname in filenames:
-                if (fname.startswith("test") or fname.startswith("gen")) and fname.endswith(".kg"):
-                    ran_tests = True
-                    klong = KlongInterpreter()
-                    fullpath = os.path.join(dirpath, fname)
-                    klong['fullpath'] = fullpath
-                    try:
-                        klong('.l("tests/kgtests/runner.kg")')
-                        if fname.startswith("gen"):
-                            print(f"testing (line by line) {fname}...")
-                            self.eval_file_by_lines(fullpath)
-                    except Exception as e:
-                        print(e)
-                        self.assertEqual(klong['err'], 1)
-                    finally:
-                        self.assertEqual(klong['err'], 0)
-
-        self.assertTrue(ran_tests)

tests/test_known_bugs.py

@@ -1,206 +0,0 @@
-import unittest
-
-import pandas as pd
-from utils import *
-
-from klongpy import KlongInterpreter
-from klongpy.core import KGChar, KGSym
-
-
-class TestKnownBugsSuite(unittest.TestCase):
-
-    @unittest.skip
-    def test_array_substitution(self):
-        # [!10] should eval to [:! 10] but it doesn't
-        klong = KlongInterpreter()
-        r = klong('[!10]')
-        self.assertTrue(kg_equal(r, [KGSym('!'), 10]))
-        # [3*a^2] should eval to [3 :* :a :^ 2] but it doesn't
-        r = klong('[3*a^2]')
-        self.assertTrue(kg_equal(r, [3, KGSym('*'), KGSym('a'), KGSym('^'), 2]))
-
-    @unittest.skip
-    def test_should_fail_parsing(self):
-        """
-           this is a bug in both original Klong and KlongPy:
-           fn::{[a b c]::1;a::1;b::2;c::3} the :: after variable declaration is a syntax error
-        """
-        pass
-
-    @unittest.skip
-    def test_calling_time_with_lambda(self):
-        """
-        .l("time")
-        a::!1000;#a
-        time({{{x*x}'a}'!1000})
-        """
-        # time will evaluate the lambda in such a way that the gap between the first .pc() and the second .pc() is
-        # very small, so the time will be close to 0.
-
-    @unittest.skip
-    def test_table_access_with_at(self):
-        data = {'col1': np.arange(10)}
-        df = pd.DataFrame(data)
-        klong = KlongInterpreter()
-        klong['df'] = df
-        klong('.py("klongpy.db")')
-        klong('T::.table(df)')
-        # @ should work the same as a dictionary
-        r = klong('T@"col1"')
-        self.assertTrue(kg_equal(r, data['col1']))
-
-    @unittest.skip
-    def test_extra_spaces(self):
-        klong = KlongInterpreter()
-        r = klong("a::{ 1 + 1 };a()")
-        self.assertEqual(r, 2)
-
-    @unittest.skip
-    def test_semicolon_string_arg(self):
-        klong = KlongInterpreter()
-        klong('f::{x,y}')
-        r = klong('f("hello";";")')
-        self.assertEqual(r, "hello;")
-
-    @unittest.skip
-    def test_wrap_join(self):
-        klong = KlongInterpreter()
-        klong("q::[3 8]")
-        r = klong("q[0],q[-1]")
-        self.assertTrue(kg_equal(r, [3,8]))
-        r = klong("(q[0],q[-1])")
-        self.assertTrue(kg_equal(r, [3,8]))
-
-    @unittest.skip
-    def test_append_empty_dictionaries(self):
-        klong = KlongInterpreter()
-        r = klong("A::[];A::A,:{};A::A,:{};A::A,:{};A")
-        self.assertTrue(kg_equal(r, [{}, {}, {}]))
-
-    @unittest.skip
-    def test_extra_chars_ignored(self):
-        klong = KlongInterpreter()
-        with self.assertRaises(Exception):
-            klong("aggs::{[a];a:::{}}}}")
-
-    @unittest.skip
-    def test_tested_arity(self):
-        # inner x is not seen in arity calculation
-        #        {.pyc(x,"ticker";[];:{})}'1#symbols
-        pass
-
-    @unittest.skip
-    def test_monad_argument_returned(self):
-        """
-        Test that a monadic lambda can be passed as an argument, returned, and then called.
-        """
-        klong = KlongInterpreter()
-        klong('fn::{x+10}')
-        klong('foo::{x}')
-        r = klong('foo(fn)(2)')
-        self.assertEqual(r, 12)
-
-    @unittest.skip
-    def test_triad_as_arguments_with_currying(self):
-        """
-        Test that two monads can be passed as arguments to a klong function.
-        """
-        klong = KlongInterpreter()
-        klong('fn::{x+10+y*z}')
-        klong('foo::{x(2;;)}')
-        r = klong('w::foo(fn;;)')
-        r = klong('w(;3;5)')
-        self.assertEqual(r, 2+10+3*5)
-
-    @unittest.skip
-    def test_fail_non_terminated_string(self):
-        klong = KlongInterpreter()
-        with self.assertRaises(Exception):
-            klong('a::"T')
-
-    @unittest.skip
-    def test_define_nilad_with_subcall(self):
-        klong = KlongInterpreter()
-        klong("nt::{x}")
-        klong('newt::{nt([["1" 2] ["3" 4] ["5" 6]])}')
-
-    @unittest.skip
-    def test_join_two_dict(self):
-        klong = KlongInterpreter()
-        klong("b:::{[1 2]}")
-        klong("c:::{[3 4]}")
-        r = klong("b,c")
-        self.assertEqual(r, {1: 2, 3: 4})
-
-    @unittest.skip
-    def test_nested_dict(self):
-        klong = KlongInterpreter()
-        klong('c:::{["GET" :{["/" 2]}]}')
-        r = klong('(c?"GET")?"/"')
-        self.assertEqual(r, 2)
-
-    @unittest.skip
-    def test_dict_inner_create_syntax(self):
-        klong = KlongInterpreter()
-        with self.assertRaises(RuntimeError):
-            # should fail to parse
-            r = klong(":{[1 :{[2 3]}}")
-
-    @unittest.skip
-    def test_dict_inner_create(self):
-        # this creates a KGCall to wrap the inner dict, which is generally correct for
-        klong = KlongInterpreter()
-        r = klong(":{[1 :{[2 3]}]}")
-        self.assertEqual(r[1], {2: 3})
-
-    @unittest.skip
-    def test_match_nested_array(self):
-        klong = KlongInterpreter()
-        r = klong('[7,7,7]~[7,7,7]')
-        self.assertEqual(r,1)
-
-    @unittest.skip
-    def test_monad_not_getting_called(self):
-        klong = KlongInterpreter()
-        klong("""
-BESTF::10^9;RESETF::{BESTF::10^9}
-ITER::{1};
-RUNX::{{x;ITER()}{x}:~ITER()}
-SCAN::{RESETF();RUNX();BESTF}
-        """)
-        r = klong("SCAN()")
-        self.assertEqual(r,99)
-
-    @unittest.skip
-    def test_take_nested_array(self):
-        klong = KlongInterpreter()
-        r = klong("(4)#[[0 0]]")
-        self.assertTrue(kg_equal(r,[[0,0],[0,0],[0,0],[0,0]]))
-
-    @unittest.skip
-    def test_fall_call_undefined_fn(self):
-        klong = KlongInterpreter()
-        with self.assertRaises(RuntimeError):
-            klong('R(1)')
-
-    @unittest.skip
-    def test_at_in_depth_strings(self):
-        # DIFF: this isn't yet supported in Klong
-        klong = KlongInterpreter()
-        r = klong('["1234","5678"]:@[0 1]')
-        self.assertEqual(r,KGChar('2'))
-
-    @unittest.skip
-    def test_dot_f_complex(self):
-        """ TODO: this is from the ref doc but doesn't work in klong either """
-        klong = KlongInterpreter()
-        klong("fr::{:[@x;0;1+|/{.f(x)}'x]}")
-        self.assert_eval_cmp('fr(0)', '[]', klong=klong)
-        self.assert_eval_cmp('fr(1)', '[1]', klong=klong)
-        self.assert_eval_cmp('fr(3)', '[1 1 1]', klong=klong)
-        self.assert_eval_cmp('fr(10)', '[1 1 1 1 1 1 1 1 1 1]', klong=klong)
-        klong("fr::{:[@x;0;1+|/.f'x]}")
-        self.assert_eval_cmp('fr(0)', '[]', klong=klong)
-        self.assert_eval_cmp('fr(1)', '[1]', klong=klong)
-        self.assert_eval_cmp('fr(3)', '[1 1 1]', klong=klong)
-        self.assert_eval_cmp('fr(10)', '[1 1 1 1 1 1 1 1 1 1]', klong=klong)

tests/test_prog.py

@@ -1,107 +0,0 @@
-import unittest
-from klongpy import KlongInterpreter
-from klongpy.core import KGSym, read_sys_comment
-from utils import *
-
-class TestProg(unittest.TestCase):
-
-    def test_read_string_vs_op(self):
-        """
-        This test makes sure that we can parse a string that's the same character string as an operation.
-        """
-        klong = KlongInterpreter()
-        r = klong("""
-        bar::{x}
-lin2::{bar("+")}
-lin2()
-        """)
-        self.assertEqual(r,'+')
-
-    def test_read_string_arg(self):
-        """
-        This test makes sure that we can parse a string that's the same character string as an operation.
-        """
-        klong = KlongInterpreter()
-        r = klong("""
-lin2::{.d("+");{.d((2+#x):^"-");.d("+")}'x;.p("");x}
-lin2(1)
-            """)
-        self.assertEqual(r, 1)
-
-    def test_prog_arr(self):
-        klong = KlongInterpreter()
-        r = klong.prog("[[]]")[1][0]
-        r = [x.tolist() for x in r]
-        self.assertEqual(str(r), "[[]]")
-
-    @unittest.skip
-    def test_prog_define(self):
-        klong = KlongInterpreter()
-        r = klong.prog('t::{:[~y~z;fail(x;y;z);[]]}')[1]
-        self.assertEqual(len(r), 1)
-        self.assertEqual(r[0].a.a, "::")
-        self.assertEqual(r[0].args[0], KGSym("t"))
-        self.assertEqual(len(r[0].args[1]), 1)
-        self.assertEqual(len(r[0].args[1][0]), 3)
-
-    @unittest.skip
-    def test_prog_fn(self):
-        klong = KlongInterpreter()
-        r = klong.prog('t("fv()"     ; fv()     ; 1)')[1]
-        self.assertEqual(len(r), 1)
-        self.assertEqual(len(r[0]), 2)
-        self.assertEqual(len(r[0][1]), 3)
-
-    @unittest.skip
-    def test_prog_multi_prog(self):
-        klong = KlongInterpreter()
-        r = klong.prog('fv::{[a];a::1;a} ; t("fv()"     ; fv()     ; 1)')[1]
-        self.assertEqual(len(r), 2)
-        self.assertEqual(len(r[0]), 3)
-        self.assertEqual(len(r[0][2]), 1)
-        self.assertEqual(len(r[0][2][0]), 3)
-        self.assertEqual(len(r[0][2][0][0]), 1)
-        self.assertEqual(len(r[0][2][0][1]), 3)
-        self.assertEqual(len(r[1]), 2)
-        self.assertEqual(len(r[1][1]), 3)
-        r = klong('fv::{[a];a::1;a} ; fv()')
-        self.assertEqual(r[1], 1)
-
-    @unittest.skip
-    def test_prog(self):
-        klong = KlongInterpreter()
-        s = '"{x-y}:(1;)@2"        ; {x-y}:(1;)@2        ; -1'
-        i,p = klong.prog(s)
-        self.assertEqual(i, len(s))
-        self.assertEqual(p[0], '{x-y}:(1;)@2')
-        self.assertEqual(str(p[1]), "[[[[:x, '-', :y]], [1, None]], '@', 2]")
-        self.assertEqual(str(p[2]), "['-', 1]")
-        a = klong.call(p[1])
-        b = klong.call(p[2])
-        self.assertEqual(a, b)
-
-    def test_sys_comment_once(self):
-        t = """
-.comment("*****")
-
-.fastpow     when set, x^y compiles to .pow(x;y)
-
-*****X
-        """
-        x = t.index("X")
-        cmd = '.comment("*****")'
-        i = read_sys_comment(t, t.index(cmd)+len(cmd), "*****")
-        assert i == x
-
-    def test_sys_comment_replicated(self):
-        t = """
-.comment("*****")
-
-.fastpow     when set, x^y compiles to .pow(x;y)
-
-************************************************************************X
-        """
-        x = t.index("X")
-        cmd = '.comment("*****")'
-        i = read_sys_comment(t, t.index(cmd)+len(cmd), "*****")
-        assert i == x

tests/test_reshape_strings.py

@@ -1,33 +0,0 @@
-import unittest
-import numpy as np
-
-from klongpy import KlongInterpreter
-from tests.utils import kg_equal
-
-class TestReshapeStrings(unittest.TestCase):
-    def setUp(self):
-        self.klong = KlongInterpreter()
-
-    def test_reshape_string_len1(self):
-        r = self.klong('[2 2]:^"a"')
-        self.assertTrue(kg_equal(r, np.asarray(["aa", "aa"], dtype=object)))
-
-    def test_reshape_string_len2(self):
-        r = self.klong('[2 2]:^"ab"')
-        self.assertTrue(kg_equal(r, np.asarray(["ab", "ab"], dtype=object)))
-
-    def test_reshape_string_len3(self):
-        r = self.klong('[2 2]:^"abc"')
-        self.assertTrue(kg_equal(r, np.asarray(["ab", "ca"], dtype=object)))
-
-    def test_reshape_string_len4(self):
-        r = self.klong('[2 2]:^"abcd"')
-        self.assertTrue(kg_equal(r, np.asarray(["ab", "cd"], dtype=object)))
-
-    def test_reshape_string_larger_shape(self):
-        r = self.klong('[3 3]:^"abcd"')
-        self.assertTrue(kg_equal(r, np.asarray(["abc", "dab", "cda"], dtype=object)))
-
-
-if __name__ == '__main__':
-    unittest.main()