py2rb master 0d2fbc5a86b82707a1d83241a21af6b2cc22c0b8

py2rb examples

-- [python] ---------
* tests/algorithms/sqrt.py
def abs(x):
    if x > 0:
        return x
    else:
        return -x

def sqrt(x):
    eps = 1e-10
    x = float(x)
    r = x/2
    residual = r**2 - x
    while abs(residual) > eps:
        r_d = -residual/(2*r)
        r += r_d
        residual = r**2 - x
    return r

def p(x):
    prec = 11
    l = list(iter(str(x)))[:prec]
    if not "." in l:
        l.append(".")
        l.append("0")
    while len(l) < prec:
        l.append("0")
    s = ""
    for c in l:
        s += c
    return s

print((p(sqrt(1))))
print((p(sqrt(2))))
print((p(sqrt(3))))
print((p(sqrt(4))))
print((p(sqrt(5))))
print((p(sqrt(6))))
print((p(sqrt(7000))))
-- [ruby] -----------
$ py2rb tests/algorithms/sqrt.py
def abs(x)
  if x > 0
    return x
  else
    return -x
  end
end
def sqrt(x)
  eps = 1e-10
  x = x.to_f
  r = x / 2.to_f
  residual = (r ** 2) - x
  while residual.abs > eps
    r_d = (-residual) / (2 * r).to_f
    r += r_d
    residual = (r ** 2) - x
  end
  return r
end
def p(x)
  prec = 11
  l = x.to_s.each.to_a[0...prec]
  if is_bool(!l.include?("."))
    l.push(".")
    l.push("0")
  end
  while l.size < prec
    l.push("0")
  end
  s = ""
  for c in l
    s += c
  end
  return s
end
print(p(sqrt(1)))
print(p(sqrt(2)))
print(p(sqrt(3)))
print(p(sqrt(4)))
print(p(sqrt(5)))
print(p(sqrt(6)))
print(p(sqrt(7000)))

-- [python] ---------
* tests/algorithms/triangulation.py
def abs(x):
    if x > 0:
        return x
    else:
        return -x

def sqrt(x):
    eps = 1e-10
    x = float(x)
    r = x/2
    residual = r**2 - x
    while abs(residual) > eps:
        r_d = -residual/(2*r)
        r += r_d
        residual = r**2 - x
    return r

def is_on_the_left(c, a, b, pts_list):
   ax, ay = pts_list[a]
   bx, by = pts_list[b]
   cx, cy = pts_list[c]
   ux = float(bx - ax)
   uy = float(by - ay)
   vx = float(cx - ax)
   vy = float(cy - ay)
   return (ux*vy - uy*vx > 0)

def criterion(a, b, c, pts_list):
   ax, ay = pts_list[a]
   bx, by = pts_list[b]
   cx, cy = pts_list[c]
   ux = float(ax - cx)
   uy = float(ay - cy)
   vx = float(bx - cx)
   vy = float(by - cy)
   len_u = sqrt(ux*ux + uy*uy)
   len_v = sqrt(vx*vx + vy*vy)
   return (ux*vx + uy*vy)/(len_u*len_v)

def find_third_point(a, b, pts_list, edges):
    """
    Take a boundary edge (a,b), and in the list of points
    find a point 'c' that lies on the left of ab and maximizes
    the angle acb
    """
    found = 0
    minimum = 10**8   #this is dirty
    c_index = -1
    pt_index = -1
    for c_point in pts_list:
        c_index += 1
        if c_index != a and c_index != b and is_on_the_left(c_index, a, b, pts_list):
            edge_intersects = \
                    edge_intersects_edges((a, c_index), pts_list, edges) or \
                    edge_intersects_edges((b, c_index), pts_list, edges)
            if not edge_intersects:
                crit = criterion(a, b, c_index, pts_list)
                if crit < minimum:
                    minimum = crit
                    pt_index = c_index
                    found = 1
    if found == 0:
        raise TriangulationError("ERROR: Optimal point not found in find_third_point().")
    return pt_index

def lies_inside(c, bdy_edges):
   for edge in bdy_edges:
       a,b = edge
       if c == a or c == b: return False
   return True

def is_boundary_edge(a, b, bdy_edges):
    """
    Checks whether edge (a, b) is in the list of boundary edges
    """
    for edge in bdy_edges:
        a0, b0 = edge
        if a == a0 and b == b0:
            return True
    return False

def triangulate_af(pts_list, bdy_edges):
    """
    Create a triangulation using the advancing front method.
    """
    # create empty list of elements
    elems = []
    bdy_edges = bdy_edges[:]
    # main loop
    while bdy_edges != []:
        # take the last item from the list of bdy edges (and remove it)
        a,b = bdy_edges.pop()
        c = find_third_point(a, b, pts_list, bdy_edges)
        elems.append((a,b,c))
        if is_boundary_edge(c, a, bdy_edges):
            bdy_edges.remove((c,a))
        else:
            bdy_edges.append((a,c))
        if is_boundary_edge(b, c, bdy_edges):
            bdy_edges.remove((b,c))
        else:
            bdy_edges.append((c,b))
    return elems

def ccw(a, b, c):
    return (c[1]-a[1])*(b[0]-a[0]) > (b[1]-a[1])*(c[0]-a[0])

def intersect(a, b, c, d):
    return ccw(a, c, d) != ccw(b, c, d) and ccw(a, b, c) != ccw(a, b, d)

def two_edges_intersect(nodes, e1, e2):
    """
    Checks whether the two edges intersect.

    It assumes that e1 and e2 are tuples of (a_id, b_id) of ids into the nodes.
    """
    a = nodes[e1[0]]
    b = nodes[e1[1]]
    c = nodes[e2[0]]
    d = nodes[e2[1]]
    return intersect(a, b, c, d)

def any_edges_intersect(nodes, edges):
    """
    Returns True if any two edges intersect.
    """
    for i in range(len(edges)):
        for j in range(i+1, len(edges)):
            e1 = edges[i]
            e2 = edges[j]
            if e1[1] == e2[0] or e1[0] == e2[1]:
                continue
            if two_edges_intersect(nodes, e1, e2):
                return True
    return False

def edge_intersects_edges(e1, nodes, edges):
    """
    Returns True if "e1" intersects any edge from "edges".
    """
    for i in range(len(edges)):
        e2 = edges[i]
        if e1[1] == e2[0] or e1[0] == e2[1]:
            continue
        if two_edges_intersect(nodes, e1, e2):
            return True
    return False

def example1():
    nodes = [
            (0, 0),
            (1, 0),
            (1, 1),
            (0, 1),
            ]
    edges = [(0, 1), (1, 2), (2, 3), (3, 0)]
    elems = triangulate_af(nodes, edges)
    return nodes, edges, elems

def example2():
    nodes = [
            (0, 0),
            (1, 0),
            (2, 1),
            (2, 2),
            (1, 2),
            (0.5, 1.5),
            (0, 1),
            ]
    edges = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 0)]
    elems = triangulate_af(nodes, edges)
    return nodes, edges, elems

nodes, edges, elems = example1()
print("nodes", nodes)
print("edges", edges)
print("elems", elems)
if not any_edges_intersect(nodes, edges):
    print("ok")

print()
nodes, edges, elems = example2()
print("nodes", nodes)
print("edges", edges)
print("elems", elems)
if not any_edges_intersect(nodes, edges):
    print("ok")
-- [ruby] -----------
$ py2rb tests/algorithms/triangulation.py
def abs(x)
  if x > 0
    return x
  else
    return -x
  end
end
def sqrt(x)
  eps = 1e-10
  x = x.to_f
  r = x / 2.to_f
  residual = (r ** 2) - x
  while residual.abs > eps
    r_d = (-residual) / (2 * r).to_f
    r += r_d
    residual = (r ** 2) - x
  end
  return r
end
def is_on_the_left(c, a, b, pts_list)
  ax,ay = pts_list[a]
  bx,by = pts_list[b]
  cx,cy = pts_list[c]
  ux = (bx - ax).to_f
  uy = (by - ay).to_f
  vx = (cx - ax).to_f
  vy = (cy - ay).to_f
  return (ux * vy) - (uy * vx) > 0
end
def criterion(a, b, c, pts_list)
  ax,ay = pts_list[a]
  bx,by = pts_list[b]
  cx,cy = pts_list[c]
  ux = (ax - cx).to_f
  uy = (ay - cy).to_f
  vx = (bx - cx).to_f
  vy = (by - cy).to_f
  len_u = sqrt((ux * ux) + (uy * uy))
  len_v = sqrt((vx * vx) + (vy * vy))
  return ((ux * vx) + (uy * vy)) / (len_u * len_v).to_f
end
def find_third_point(a, b, pts_list, edges)
  # 
  #   Take a boundary edge (a,b), and in the list of points
  #   find a point 'c' that lies on the left of ab and maximizes
  #   the angle acb
  #   
  found = 0
  minimum = 10 ** 8
  c_index = -1
  pt_index = -1
  for c_point in pts_list
    c_index += 1
    if is_bool(c_index != a && c_index != b && is_on_the_left(c_index, a, b, pts_list))
      edge_intersects = edge_intersects_edges([a, c_index], pts_list, edges) || edge_intersects_edges([b, c_index], pts_list, edges)
      if is_bool(!edge_intersects)
        crit = criterion(a, b, c_index, pts_list)
        if crit < minimum
          minimum = crit
          pt_index = c_index
          found = 1
        end
      end
    end
  end
  if found == 0
    raise TriangulationError, "ERROR: Optimal point not found in find_third_point()."
  end
  return pt_index
end
def lies_inside(c, bdy_edges)
  for edge in bdy_edges
    a,b = edge
    if is_bool(c == a || c == b)
      return false
    end
  end
  return true
end
def is_boundary_edge(a, b, bdy_edges)
  # 
  #   Checks whether edge (a, b) is in the list of boundary edges
  #   
  for edge in bdy_edges
    a0,b0 = edge
    if is_bool(a == a0 && b == b0)
      return true
    end
  end
  return false
end
def triangulate_af(pts_list, bdy_edges)
  # 
  #   Create a triangulation using the advancing front method.
  #   
  elems = []
  bdy_edges = bdy_edges[0..-1]
  while bdy_edges != []
    a,b = bdy_edges.pop()
    c = find_third_point(a, b, pts_list, bdy_edges)
    elems.push([a, b, c])
    if is_bool(is_boundary_edge(c, a, bdy_edges))
      bdy_edges.remove([c, a])
    else
      bdy_edges.push([a, c])
    end
    if is_bool(is_boundary_edge(b, c, bdy_edges))
      bdy_edges.remove([b, c])
    else
      bdy_edges.push([c, b])
    end
  end
  return elems
end
def ccw(a, b, c)
  return (c[1] - a[1]) * (b[0] - a[0]) > (b[1] - a[1]) * (c[0] - a[0])
end
def intersect(a, b, c, d)
  return ccw(a, c, d) != ccw(b, c, d) && ccw(a, b, c) != ccw(a, b, d)
end
def two_edges_intersect(nodes, e1, e2)
  # 
  #   Checks whether the two edges intersect.
  # 
  #   It assumes that e1 and e2 are tuples of (a_id, b_id) of ids into the nodes.
  #   
  a = nodes[e1[0]]
  b = nodes[e1[1]]
  c = nodes[e2[0]]
  d = nodes[e2[1]]
  return intersect(a, b, c, d)
end
def any_edges_intersect(nodes, edges)
  # 
  #   Returns True if any two edges intersect.
  #   
  for i in edges.size.times
    for j in (i + 1).upto(edges.size-1)
      e1 = edges[i]
      e2 = edges[j]
      if is_bool(e1[1] == e2[0] || e1[0] == e2[1])
        next
      end
      if is_bool(two_edges_intersect(nodes, e1, e2))
        return true
      end
    end
  end
  return false
end
def edge_intersects_edges(e1, nodes, edges)
  # 
  #   Returns True if \"e1\" intersects any edge from \"edges\".
  #   
  for i in edges.size.times
    e2 = edges[i]
    if is_bool(e1[1] == e2[0] || e1[0] == e2[1])
      next
    end
    if is_bool(two_edges_intersect(nodes, e1, e2))
      return true
    end
  end
  return false
end
def example1()
  nodes = [[0, 0], [1, 0], [1, 1], [0, 1]]
  edges = [[0, 1], [1, 2], [2, 3], [3, 0]]
  elems = triangulate_af(nodes, edges)
  return [nodes, edges, elems]
end
def example2()
  nodes = [[0, 0], [1, 0], [2, 1], [2, 2], [1, 2], [0.5, 1.5], [0, 1]]
  edges = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 0]]
  elems = triangulate_af(nodes, edges)
  return [nodes, edges, elems]
end
nodes,edges,elems = example1()
print("nodes", nodes)
print("edges", edges)
print("elems", elems)
if is_bool(!any_edges_intersect(nodes, edges))
  print("ok")
end
print()
nodes,edges,elems = example2()
print("nodes", nodes)
print("edges", edges)
print("elems", elems)
if is_bool(!any_edges_intersect(nodes, edges))
  print("ok")
end

-- [python] ---------
* tests/basic/assert.py
try:
    assert True, "no message"
except AssertionError as err:
    print('AssertionError :', err)
except:
    print('Error :')

try:
    assert False, "error message"
except AssertionError as err:
    print('AssertionError :', err)
except:
    print('Error :')
-- [ruby] -----------
$ py2rb tests/basic/assert.py
begin
  raise "no message" unless true
rescue RuntimeError => err
  print("AssertionError :", err)
rescue
  print("Error :")
end
begin
  raise "error message" unless false
rescue RuntimeError => err
  print("AssertionError :", err)
rescue
  print("Error :")
end

-- [python] ---------
* tests/basic/assign.py


x = y = 1
print(x)
print(y)

y += 3
print(x)
print(y)

x, y = 1, 2
print(x)
print(y)

x = [3]
print(x)

x,y = [3,2]
print(x)
print(y)

x, = [3]
print(x)
-- [ruby] -----------
$ py2rb tests/basic/assign.py
x = y = 1
print(x)
print(y)
y += 3
print(x)
print(y)
x,y = [1, 2]
print(x)
print(y)
x = [3]
print(x)
x,y = [3, 2]
print(x)
print(y)
x, = [3]
print(x)

-- [python] ---------
* tests/basic/assign_slice.py

a = [1,2,3,4,5,6,7]

a[4:6] = ['a','b']

#def show(x):
def show(a):
    print("----")
    for x in a:
        print(x)

show(a)


a[2:4] = ['z']

show(a)

a[0:2] = ['abc','def','abc','def']

show(a)
-- [ruby] -----------
$ py2rb tests/basic/assign_slice.py
a = [1, 2, 3, 4, 5, 6, 7]
a[4...6] = ["a", "b"]
def show(a)
  print("----")
  for x in a
    print(x)
  end
end
show(a)
a[2...4] = ["z"]
show(a)
a[0...2] = ["abc", "def", "abc", "def"]
show(a)

-- [python] ---------
* tests/basic/augassign.py

a = 1
a += 1
print(a)
a += 3
print(a)
a -= 2
print(a)
-- [ruby] -----------
$ py2rb tests/basic/augassign.py
a = 1
a += 1
print(a)
a += 3
print(a)
a -= 2
print(a)

-- [python] ---------
* tests/basic/augassign2.py
def f1(x):
    return x

def f2(x):
    return x + 5

def f3(x):
    a = x + 1
    return a - 5

def f3b(x):
    a = x + 1
    a -= 5
    return a

def f3c(x):
    a = float(x) + 1
    a /= 5
    return a

def f3d(x):
    a = x + 1
    a *= 5
    return a

def f3e(x):
    a = x + 1
    a += 5
    return a

def f4(x):
    if x:
        return 5
    else:
        return 6

def f5(x):
    a = 1
    if x:
        a = a + 1
    else:
        a = a - 1
    return a

print(f1(3))
print(f2(3))
print(f3(3))
print(f3b(3))
print(f3c(3))
print(f3d(3))
print(f3e(3))
print(f4(True))
print(f4(False))
print(f5(True))
print(f5(False))
-- [ruby] -----------
$ py2rb tests/basic/augassign2.py
def f1(x)
  return x
end
def f2(x)
  return x + 5
end
def f3(x)
  a = x + 1
  return a - 5
end
def f3b(x)
  a = x + 1
  a -= 5
  return a
end
def f3c(x)
  a = x.to_f + 1
  a = a / 5.to_f
  return a
end
def f3d(x)
  a = x + 1
  a *= 5
  return a
end
def f3e(x)
  a = x + 1
  a += 5
  return a
end
def f4(x)
  if is_bool(x)
    return 5
  else
    return 6
  end
end
def f5(x)
  a = 1
  if is_bool(x)
    a = a + 1
  else
    a = a - 1
  end
  return a
end
print(f1(3))
print(f2(3))
print(f3(3))
print(f3b(3))
print(f3c(3))
print(f3d(3))
print(f3e(3))
print(f4(true))
print(f4(false))
print(f5(true))
print(f5(false))

-- [python] ---------
* tests/basic/binaryops.py

x = 1
y = 2
z = 3

print(10 % z)
print(y*x)
print(y-z)
print(y+x+z)
print((5 + 4) / 2)
print(9 / 2)
print(9 // 2)
print(10 ** 2)

-- [ruby] -----------
$ py2rb tests/basic/binaryops.py
x = 1
y = 2
z = 3
print(10 % z)
print(y * x)
print(y - z)
print((y + x) + z)
print((5 + 4) / 2.to_f)
print(9 / 2.to_f)
print(9 / 2)
print(10 ** 2)

-- [python] ---------
* tests/basic/break.py

x = 0

while True:
    x = x + 1
    print(x)
    if x > 10:
        break
-- [ruby] -----------
$ py2rb tests/basic/break.py
x = 0
while true
  x = x + 1
  print(x)
  if x > 10
    break
  end
end

-- [python] ---------
* tests/basic/class.py


class foobar(object):
    
    x = 1

    def __init__(self):
        self.foovar = 1

    def foo(self,x):
        self.foovar = self.foovar + x

    def bar(self):
        print(self.foovar)

f = foobar()
f.bar()
f.foo(1)
f.foo(2)
f.bar()
f.bar()
f.foo(-1)
f.bar()
f.foo(7)
f.bar()


-- [ruby] -----------
$ py2rb tests/basic/class.py
class Foobar
  @@x = 1
  def initialize()
    @foovar = 1
  end
  def foo(x)
    @foovar = @foovar + x
  end
  def bar()
    print(@foovar)
  end
  def self.x; @@x; end
  def self.x=(val); @@x=val; end
  def x; @x = @@x if @x.nil?; @x; end
  def x=(val); @x=val; end
end
f = Foobar.new()
f.bar()
f.foo(1)
f.foo(2)
f.bar()
f.bar()
f.foo(-1)
f.bar()
f.foo(7)
f.bar()

-- [python] ---------
* tests/basic/class2.py
class Class1(object):

    def __init__(self):
        pass

    def test1(self):
        return 5

class Class2(object):

    def test1(self):
        return 6

class Class3(object):

    def test1(self, x):
        return self.test2(x)-1

    def test2(self, x):
        return 2*x

a = Class1()
print(a.test1())

a = Class2()
print(a.test1())

a = Class3()
print(a.test1(3))
print(a.test2(3))
-- [ruby] -----------
$ py2rb tests/basic/class2.py
class Class1
  def initialize()
    # pass
  end
  def test1()
    return 5
  end
end
class Class2
  def test1()
    return 6
  end
end
class Class3
  def test1(x)
    return test2(x) - 1
  end
  def test2(x)
    return 2 * x
  end
end
a = Class1.new()
print(a.test1())
a = Class2.new()
print(a.test1())
a = Class3.new()
print(a.test1(3))
print(a.test2(3))

-- [python] ---------
* tests/basic/class3.py
class A(object):
    v = 1

a = A()
XX = A
x = XX()
print(x.v)
-- [ruby] -----------
$ py2rb tests/basic/class3.py
class A
  @@v = 1
  def self.v; @@v; end
  def self.v=(val); @@v=val; end
  def v; @v = @@v if @v.nil?; @v; end
  def v=(val); @v=val; end
end
a = A.new()
XX = A
x = XX.()
print(x.v)

-- [python] ---------
* tests/basic/class4.py
def create(cls):
    return cls()

class A(object):
    def m(self):
        print("A.m()")

a = A()
a.m()

b = create(A)
b.m()
-- [ruby] -----------
$ py2rb tests/basic/class4.py
def create(cls)
  return cls.()
end
class A
  def m()
    print("A.m()")
  end
end
a = A.new()
a.m()
b = create(A)
b.m()

-- [python] ---------
* tests/basic/class5.py
def create(cls):
    return cls()

class A:
    def m(self):
        print("A.m()")

a = A()
a.m()

b = create(A)
b.m()
-- [ruby] -----------
$ py2rb tests/basic/class5.py
def create(cls)
  return cls.()
end
class A
  def m()
    print("A.m()")
  end
end
a = A.new()
a.m()
b = create(A)
b.m()

-- [python] ---------
* tests/basic/class6.py
def create(cls):
    return cls()

class A:
    def __init__(self):
      self.msg = "A.m()"
    def m(self):
        print(self.msg)

a = A()
a.m()

b = create(A)
b.m()
-- [ruby] -----------
$ py2rb tests/basic/class6.py
def create(cls)
  return cls.()
end
class A
  def initialize()
    @msg = "A.m()"
  end
  def m()
    print(@msg)
  end
end
a = A.new()
a.m()
b = create(A)
b.m()

-- [python] ---------
* tests/basic/closure.py

def factory(x):

    def fn():
        return x
    
    return fn

a1 = factory("foo")
a2 = factory("bar")
print(a1())
print(a2())
-- [ruby] -----------
$ py2rb tests/basic/closure.py
def factory(x)
  fn = lambda do
    return x
  end
  return fn
end
a1 = factory("foo")
a2 = factory("bar")
print(a1.())
print(a2.())

-- [python] ---------
* tests/basic/closure_in_class.py

class foo(object):

    def factory(self, x):

        def fn():
            return x

        return fn

f = foo()


a1 = f.factory("foo")
a2 = f.factory("bar")
print(a1())
print(a2())
-- [ruby] -----------
$ py2rb tests/basic/closure_in_class.py
class Foo
  def factory(x)
    fn = lambda do
      return x
    end
    return fn
  end
end
f = Foo.new()
a1 = f.factory("foo")
a2 = f.factory("bar")
print(a1.())
print(a2.())

-- [python] ---------
* tests/basic/continue.py

for x in range(0,20):
    if x > 10 and x < 17:
        continue
    print(x)
-- [ruby] -----------
$ py2rb tests/basic/continue.py
for x in 0.upto(20-1)
  if is_bool(x > 10 && x < 17)
    next
  end
  print(x)
end

-- [python] ---------
* tests/basic/del_array.py

mylist = [1,2,3,4,5]

del mylist[3]

for x in range(0,len(mylist)):
    print(mylist[x])
-- [ruby] -----------
$ py2rb tests/basic/del_array.py
mylist = [1, 2, 3, 4, 5]
mylist.delete_at(3)
for x in 0.upto(mylist.size-1)
  print(mylist[x])
end

-- [python] ---------
* tests/basic/del_attr.py


class spam:

    def __init__(self):
        self.eggs = 0

    def addegg(self):
        try:
            if self.eggs:
                self.eggs += 1
            else:
                self.eggs = 1
        except:
            self.eggs = 1

    def printit(self):
        try:
            if self.eggs:
                print(self.eggs)
            else:
                print("no eggs")
        except:
            print("no eggs")

    
s = spam()
s.addegg()
s.addegg()
s.printit()
s.addegg()
s.printit()
del s.eggs
s.printit()
s.addegg()
s.addegg()
s.printit()
-- [ruby] -----------
$ py2rb tests/basic/del_attr.py
class Spam
  def initialize()
    @eggs = 0
  end
  def addegg()
    begin
      if is_bool(@eggs)
        @eggs += 1
      else
        @eggs = 1
      end
    rescue
      @eggs = 1
    end
  end
  def printit()
    begin
      if is_bool(@eggs)
        print(@eggs)
      else
        print("no eggs")
      end
    rescue
      print("no eggs")
    end
  end
end
s = Spam.new()
s.addegg()
s.addegg()
s.printit()
s.addegg()
s.printit()
s.instance_eval { remove_instance_variable(:@eggs) }
s.printit()
s.addegg()
s.addegg()
s.printit()

-- [python] ---------
* tests/basic/del_dict.py

mydict = {}

mydict["abc"] = "def"
mydict["def"] = "abc"
mydict["xyz"] = "rst"

print(mydict["abc"])
print(mydict["def"])
print(mydict["xyz"])

del mydict["def"]

if "abc" in mydict:
    print("abc in mydict")
else:
    print("abc not in mydict")

if "def" in mydict:
    print("def in mydict")
else:
    print("def not in mydict")

if "xyz" in mydict:
    print("xyz in mydict")
else:
    print("xyz not in mydict")
-- [ruby] -----------
$ py2rb tests/basic/del_dict.py
mydict = {}
mydict["abc"] = "def"
mydict["def"] = "abc"
mydict["xyz"] = "rst"
print(mydict["abc"])
print(mydict["def"])
print(mydict["xyz"])
mydict.delete("def")
if mydict.include?("abc")
  print("abc in mydict")
else
  print("abc not in mydict")
end
if mydict.include?("def")
  print("def in mydict")
else
  print("def not in mydict")
end
if mydict.include?("xyz")
  print("xyz in mydict")
else
  print("xyz not in mydict")
end

-- [python] ---------
* tests/basic/del_slice.py

mylist = [1,2,3,4,5]

del mylist[1:3]

for x in range(0,len(mylist)):
    print(mylist[x])
-- [ruby] -----------
$ py2rb tests/basic/del_slice.py
mylist = [1, 2, 3, 4, 5]
mylist.slice!(1...3)
for x in 0.upto(mylist.size-1)
  print(mylist[x])
end

-- [python] ---------
* tests/basic/dictcomp1.py
foo = {key.upper(): data * 2 for key, data in {'a': 7, 'b': 5}.items()}
print(foo['A'])
print(foo['B'])
-- [ruby] -----------
$ py2rb tests/basic/dictcomp1.py
foo = {"a" => 7, "b" => 5}.to_a().map{|key, data|[key.upcase(), data * 2]}.to_h
print(foo["A"])
print(foo["B"])

-- [python] ---------
* tests/basic/dictcomp2.py
foo = {key.upper(): data * 2 for key, data in {'a': 7, 'b': 5}.items() if data > 6}
print(len(foo))
print(foo['A'])
-- [ruby] -----------
$ py2rb tests/basic/dictcomp2.py
foo = {"a" => 7, "b" => 5}.to_a().select{|key, data| data > 6}.map{|key, data|[key.upcase(), data * 2]}.to_h
print(foo.size)
print(foo["A"])

-- [python] ---------
* tests/basic/dictionary.py

foo = { 'a':'b', 'c':'d' }

print(foo['a'])
print(foo['c'])

if 'a' in foo:
    print("a in foo")
-- [ruby] -----------
$ py2rb tests/basic/dictionary.py
foo = {"a" => "b", "c" => "d"}
print(foo["a"])
print(foo["c"])
if foo.include?("a")
  print("a in foo")
end

-- [python] ---------
* tests/basic/dictionary2.py
def dict1():
    a = {1: 3, "s": 4}
    return len(a)

def dict2():
    a = {1: 3, "s": 4}
    b = a[1] + a["s"]
    return b

def dict3():
    a = {}
    a[1] = 3
    a["s"] = 4
    b = a[1] + a["s"]
    return b

print(dict1())
print(dict2())
print(dict3())
-- [ruby] -----------
$ py2rb tests/basic/dictionary2.py
def dict1()
  a = {1 => 3, "s" => 4}
  return a.size
end
def dict2()
  a = {1 => 3, "s" => 4}
  b = a[1] + a["s"]
  return b
end
def dict3()
  a = {}
  a[1] = 3
  a["s"] = 4
  b = a[1] + a["s"]
  return b
end
print(dict1())
print(dict2())
print(dict3())

-- [python] ---------
* tests/basic/dictionary3.py

foo = dict()
foo['a'] = 'b'
foo['c'] = 'd'

print(foo['a'])
print(foo['c'])

bar = dict([('a', 1), ('b', 2), ('c', 3)])
if 'a' in bar:
    print("a in bar")
-- [ruby] -----------
$ py2rb tests/basic/dictionary3.py
foo = {}
foo["a"] = "b"
foo["c"] = "d"
print(foo["a"])
print(foo["c"])
bar = {"a" => 1, "b" => 2, "c" => 3}
if bar.include?("a")
  print("a in bar")
end

-- [python] ---------
* tests/basic/docstring.py

class myclass(object):

    """This is a class that really says something"""

    def __init__(self,msg):
        self.msg = msg

    def saysomething(self):
        print(self.msg)
        
m = myclass("hello")

m.saysomething()
-- [ruby] -----------
$ py2rb tests/basic/docstring.py
class Myclass
  # This is a class that really says something
  def initialize(msg)
    @msg = msg
  end
  def saysomething()
    print(@msg)
  end
end
m = Myclass.new("hello")
m.saysomething()

-- [python] ---------
* tests/basic/embedding.py
"""py2rb-verbatim:
function foo(x) {
    print(x);
}
"""

"""py2rb-skip-begin"""
def foo(x):
    print(x)
"""py2rb-skip-end"""

foo('bar')
-- [ruby] -----------
$ py2rb tests/basic/embedding.py
# py2rb-verbatim:
# function foo(x) {
#     print(x);
# }
# 
# py2rb-skip-begin
def foo(x)
  print(x)
end
# py2rb-skip-end
foo("bar")

-- [python] ---------
* tests/basic/fib.py



def fib(x):
    if x == 1:
        return x
    else:
        return x*fib(x-1)

print(fib(4))
-- [ruby] -----------
$ py2rb tests/basic/fib.py
def fib(x)
  if x == 1
    return x
  else
    return x * (fib(x - 1))
  end
end
print(fib(4))

-- [python] ---------
* tests/basic/float2int.py

for f in [123.456,1.1,-0.00045,-1.45,1.5,1022423.22]:
    i = int(f)
    print(i)
-- [ruby] -----------
$ py2rb tests/basic/float2int.py
for f in [123.456, 1.1, -0.00045, -1.45, 1.5, 1022423.22]
  i = f.to_i
  print(i)
end

-- [python] ---------
* tests/basic/for_in.py
# iterating over a list
print('-- list --')
a = [1,2,3,4,5]
for x in a:
    print(x)

# iterating over a tuple
print('-- tuple else case --')
a = ('cats','dogs','squirrels')
for x in a:
    print(x)
else:
    print('ok')

print('-- tuple else break case --')
for x in a:
    print(x)
    if x == 'squirrels':
        break
else:
    print('ok')

# iterating over a dictionary
# sort order in python is undefined, so need to sort the results
# explictly before comparing output

print('-- dict keys --')
a = {'a':1,'b':2,'c':3 }

keys = []
for x in a.keys():
    keys.append(x)

keys.sort()
for k in keys:
    print(k)

print('-- dict values --')
values = list()
for v in a.values():
    values.append(v)

values.sort()
for v in values:
    print(v)

items = dict()
for k, v in a.items():
    items[k] = v

print('-- dict item --')
print(items['a'])
print(items['b'])
print(items['c'])

# iterating over a string
print('-- string --')
a = 'defabc'
for x in a:
    print(x)

-- [ruby] -----------
$ py2rb tests/basic/for_in.py
print("-- list --")
a = [1, 2, 3, 4, 5]
for x in a
  print(x)
end
print("-- tuple else case --")
a = ["cats", "dogs", "squirrels"]
__dummy0__ = false
for x in a
  print(x)
  if x == a[-1]
    __dummy0__ = true
  end
end
if __dummy0__
  print("ok")
end
print("-- tuple else break case --")
__dummy1__ = false
for x in a
  print(x)
  if x == "squirrels"
    break
  end
  if x == a[-1]
    __dummy1__ = true
  end
end
if __dummy1__
  print("ok")
end
print("-- dict keys --")
a = {"a" => 1, "b" => 2, "c" => 3}
keys = []
for x in a.keys()
  keys.push(x)
end
keys.sort!()
for k in keys
  print(k)
end
print("-- dict values --")
values = []
for v in a.values()
  values.push(v)
end
values.sort!()
for v in values
  print(v)
end
items = {}
for (k, v) in a.to_a()
  items[k] = v
end
print("-- dict item --")
print(items["a"])
print(items["b"])
print(items["c"])
print("-- string --")
a = "defabc"
for x in a
  print(x)
end

-- [python] ---------
* tests/basic/for_range1.py

for x in range(1,10):
    print(x)
-- [ruby] -----------
$ py2rb tests/basic/for_range1.py
for x in 1.upto(10-1)
  print(x)
end

-- [python] ---------
* tests/basic/for_range2.py
for i in range(5):
    for j in range(i+1, 5):
        print("i:%s, j:%s" % (i,j))
-- [ruby] -----------
$ py2rb tests/basic/for_range2.py
for i in 5.times
  for j in (i + 1).upto(5-1)
    print("i:%s, j:%s" % [i, j])
  end
end

-- [python] ---------
* tests/basic/for_step.py

for x in range(19,342,13):
    print(x)
-- [ruby] -----------
$ py2rb tests/basic/for_step.py
for x in 19.step(342, 13)
  print(x)
end

-- [python] ---------
* tests/basic/getattr.py


class foobar(object):
    
    x = 1

    def __init__(self):
        self.foovar = 1

    def bar(self, y=0):
        print(self.foovar + y)

f = foobar()
a = 'bar'

getattr(f, 'bar')(y=1)
getattr(f, a)()
print(getattr(f, 'x'))
print(getattr(f, 'z', 'Nothing'))
-- [ruby] -----------
$ py2rb tests/basic/getattr.py
class Foobar
  @@x = 1
  def initialize()
    @foovar = 1
  end
  def bar(y: 0)
    print(@foovar + y)
  end
  def self.x; @@x; end
  def self.x=(val); @@x=val; end
  def x; @x = @@x if @x.nil?; @x; end
  def x=(val); @x=val; end
end
f = Foobar.new()
a = "bar"
f.getattr("bar").(y: 1)
f.getattr(a).()
print(f.getattr("x"))
print(f.getattr("z", "Nothing"))

-- [python] ---------
* tests/basic/globalvar.py


a = "spam"
b = "eggs"

print(a)
print(b)
-- [ruby] -----------
$ py2rb tests/basic/globalvar.py
a = "spam"
b = "eggs"
print(a)
print(b)

-- [python] ---------
* tests/basic/hasattr1.py
class AttrTest():
    def __init__(self):
        self.base = -1

    def __call__(self):
        if hasattr(self, 'base'):
            print("Class :base is True")
        else:
            print("Class :base is False")

attr_test = AttrTest()
if hasattr(attr_test, 'base'):
    print("base is True")
else:
    print("base is False")

if hasattr(attr_test, 'foo'):
    print("foo is True")
else:
    print("foo is False")

if hasattr(attr_test, 'bar'):
    print("bar is True")
else:
    print("bar is False")
attr_test()

#base = 'base'
#if hasattr(attr_test, base):
#    print("base is True")
#else:
#    print("base is False")
-- [ruby] -----------
$ py2rb tests/basic/hasattr1.py
class AttrTest
  def initialize()
    @base = -1
  end
  def call()
    if is_bool(self.instance_variable_defined? :@base)
      print("Class :base is True")
    else
      print("Class :base is False")
    end
  end
end
attr_test = AttrTest.new()
if is_bool(attr_test.instance_variable_defined? :@base)
  print("base is True")
else
  print("base is False")
end
if is_bool(attr_test.instance_variable_defined? :@foo)
  print("foo is True")
else
  print("foo is False")
end
if is_bool(attr_test.instance_variable_defined? :@bar)
  print("bar is True")
else
  print("bar is False")
end
attr_test.()

-- [python] ---------
* tests/basic/helloworld.py

print('hello')
print('hello world')
-- [ruby] -----------
$ py2rb tests/basic/helloworld.py
print("hello")
print("hello world")

-- [python] ---------
* tests/basic/ifelse.py
print("OK") if True else print("NG")
-- [ruby] -----------
$ py2rb tests/basic/ifelse.py
(true) ? print("OK") : print("NG")

-- [python] ---------
* tests/basic/ifs.py
def ifs1(x):
    a = 1
    if x:
        a = a + 1
        a *= 2
    else:
        a = a - 1
        a *= 4
    return a

def ifs2(x):
    a = 1
    if x > 0:
        a = a + 1
        a *= 2
    else:
        a = a - 1
        a *= 4
    return a

def ifs3(x):
    a = 1
    if x > 0:
        if x > 10:
            a = 3
        else:
            a = 4
    a = 5
    return a

def ifs4(x):
    a = 1
    if x > 0:
        if x > 10:
            a = 3
        else:
            a = 4
    else:
        a = 5
    return a

print(ifs1(True))
print(ifs1(False))
print(ifs2(1))
print(ifs2(-1))
print(ifs3(1))
print(ifs3(20))
print(ifs3(-1))
print(ifs4(1))
print(ifs4(20))
print(ifs4(-1))
-- [ruby] -----------
$ py2rb tests/basic/ifs.py
def ifs1(x)
  a = 1
  if is_bool(x)
    a = a + 1
    a *= 2
  else
    a = a - 1
    a *= 4
  end
  return a
end
def ifs2(x)
  a = 1
  if x > 0
    a = a + 1
    a *= 2
  else
    a = a - 1
    a *= 4
  end
  return a
end
def ifs3(x)
  a = 1
  if x > 0
    if x > 10
      a = 3
    else
      a = 4
    end
  end
  a = 5
  return a
end
def ifs4(x)
  a = 1
  if x > 0
    if x > 10
      a = 3
    else
      a = 4
    end
  else
    a = 5
  end
  return a
end
print(ifs1(true))
print(ifs1(false))
print(ifs2(1))
print(ifs2(-1))
print(ifs3(1))
print(ifs3(20))
print(ifs3(-1))
print(ifs4(1))
print(ifs4(20))
print(ifs4(-1))

-- [python] ---------
* tests/basic/ifs2.py
def ifs1(x):
    a = 1
    if 0 < x < 10:
        a = 2
    else:
        a = 3
    return a

def ifs2(x):
    a = 1
    if 0 == x != 10:
        a = 2
    else:
        a = 3
    return a

def ifs3(x):
    a = 1
    if 0 in x in [[0]]:
        a = 2
    else:
        a = 3
    return a

print('ifs1')
print(ifs1(-1))
print(ifs1(1))
print(ifs1(11))
print('ifs2')
print(ifs2(0))
print(ifs2(10))
print('ifs3')
print(ifs3([0]))
print(ifs3([1]))
-- [ruby] -----------
$ py2rb tests/basic/ifs2.py
def ifs1(x)
  a = 1
  if (0 < x) and (x < 10)
    a = 2
  else
    a = 3
  end
  return a
end
def ifs2(x)
  a = 1
  if (0 == x) and (x != 10)
    a = 2
  else
    a = 3
  end
  return a
end
def ifs3(x)
  a = 1
  if (x.include?(0)) and ([[0]].include?(x))
    a = 2
  else
    a = 3
  end
  return a
end
print("ifs1")
print(ifs1(-1))
print(ifs1(1))
print(ifs1(11))
print("ifs2")
print(ifs2(0))
print(ifs2(10))
print("ifs3")
print(ifs3([0]))
print(ifs3([1]))

-- [python] ---------
* tests/basic/keys.py


x = { 'foo':'bar','aaa':'bbb','xyz':'zyx','spam':'eggs' }

s = list(x.keys())
s.sort()
for k in s:
    print(k + " -> " + x[k])
-- [ruby] -----------
$ py2rb tests/basic/keys.py
x = {"foo" => "bar", "aaa" => "bbb", "xyz" => "zyx", "spam" => "eggs"}
s = x.keys().to_a
s.sort!()
for k in s
  print((k + (" -> ")) + x[k])
end

-- [python] ---------
* tests/basic/kwargs.py
def myfunc(a, b, *c, **d):
    print(a)
    print(b)
    for i in c:
        print(i)
    keys = list(d.keys())
    keys.sort()
    for i in keys:
        print(i)
        print(d[i])

myfunc(1, 2, bar='a', foo='c')
print()
myfunc(1, 2, 3, 4, bar='a', foo='c')
-- [ruby] -----------
$ py2rb tests/basic/kwargs.py
def myfunc(a, b, *c, **d)
  print(a)
  print(b)
  for i in c
    print(i)
  end
  keys = d.keys().to_a
  keys.sort!()
  for i in keys
    print(i)
    print(d[i])
  end
end
myfunc(1, 2, bar: "a", foo: "c")
print()
myfunc(1, 2, 3, 4, bar: "a", foo: "c")

-- [python] ---------
* tests/basic/kwargs2.py
def myfunc(a, b, *c, fuga='hoge', **d):
    print(a)
    print(b)
    for i in c:
        print(i)
    print(fuga)
    keys = list(d.keys())
    keys.sort()
    for i in keys:
        print(i)
        print(d[i])

myfunc(1, 2, bar='a', foo='c')
print()
myfunc(1, 2, 3, 4, bar='a', foo='c')
myfunc(1, 2, 3, 4, bar='a', fuga='hogehoge', foo='c')
-- [ruby] -----------
$ py2rb tests/basic/kwargs2.py
def myfunc(a, b, *c, fuga: "hoge", **d)
  print(a)
  print(b)
  for i in c
    print(i)
  end
  print(fuga)
  keys = d.keys().to_a
  keys.sort!()
  for i in keys
    print(i)
    print(d[i])
  end
end
myfunc(1, 2, bar: "a", foo: "c")
print()
myfunc(1, 2, 3, 4, bar: "a", foo: "c")
myfunc(1, 2, 3, 4, bar: "a", fuga: "hogehoge", foo: "c")

-- [python] ---------
* tests/basic/kwargs3.py
def myfunc(a, b=3, c=4):
    print(a)
    print(b)
    print(c)
    print()

myfunc(1)
myfunc(1, 2)
myfunc(1, 2, 3)
myfunc(1, c=3, b=4)
myfunc(1, b=4)
-- [ruby] -----------
$ py2rb tests/basic/kwargs3.py
def myfunc(a, b: 3, c: 4)
  print(a)
  print(b)
  print(c)
  print()
end
myfunc(1)
myfunc(1, b: 2)
myfunc(1, b: 2, c: 3)
myfunc(1, c: 3, b: 4)
myfunc(1, b: 4)

-- [python] ---------
* tests/basic/lambda.py

y = lambda x:x*x

print(y(4))

print((lambda x,y:x*y)(4,2))

-- [ruby] -----------
$ py2rb tests/basic/lambda.py
y = lambda{|x| x * x}
print(y.call(4))
print(lambda{|x, y| x * y}.call(4, 2))

-- [python] ---------
* tests/basic/lambda2.py
l = lambda *x: print("%s %s %s" % x)
l(1,2,3)
-- [ruby] -----------
$ py2rb tests/basic/lambda2.py
l = lambda{|*x| print("%s %s %s" % x)}
l.call(1, 2, 3)

-- [python] ---------
* tests/basic/lambda3.py
a = 5
def foo(x, y):
    x(y)

foo(lambda x: print(a), a)
-- [ruby] -----------
$ py2rb tests/basic/lambda3.py
a = 5
def foo(x, y)
  x.(y)
end
foo(lambda{|x| print(a)}, a)

-- [python] ---------
* tests/basic/lambda_map.py
ary =[1, 2]
print([x**2 for x in ary])

print([x**2 for x in [1,2]])

print(list(map(lambda x: x ** 2, ary)))
print(list(map(lambda x: x ** 2, [1,2])))
-- [ruby] -----------
$ py2rb tests/basic/lambda_map.py
ary = [1, 2]
print(ary.map{|x| x ** 2})
print([1, 2].map{|x| x ** 2})
print(ary.map{|x| x ** 2}.to_a)
print([1, 2].map{|x| x ** 2}.to_a)

-- [python] ---------
* tests/basic/list.py

x = [1,2,3,'a','b','c']
y = x[2:4]
print((x[0]))
print((x[3]))
print((y[0]))
print((y[1]))
-- [ruby] -----------
$ py2rb tests/basic/list.py
x = [1, 2, 3, "a", "b", "c"]
y = x[2...4]
print(x[0])
print(x[3])
print(y[0])
print(y[1])

-- [python] ---------
* tests/basic/list2.py
def list1(n):
    a = []
    a.append(1)
    a.append(2)
    a.append(3)
    a.append(n)
    return a[0] + a[1] + a[2] + a[3]

def list2():
    a = list(range(5))
    return str(a)

def list3():
    a = list(range(5))
    a[0] = 5
    a[4] = 0
    return str(a)

def list4():
    a = [8, 9, 10, 11, 12, 13, 14]
    return a[2:4]

def list5():
    a = [8, 9, 10, 11, 12, 13, 14]
    return a[:4]

def list6():
    a = [8, 9, 10, 11, 12, 13, 14]
    return a[1:6:2]

def list7():
    a = [8, 9, 10, 11, 12, 13, 14]
    return a[:]

def list8():
    a = [8, 9, 10, 11, 12, 13, 14]
    return a[::]

def list9():
    a = [8, 9, 10, 11, 12, 13, 14]
    return a[4:]

def list10():
    a = [8, 9, 10, 11, 12, 13, 14]
    return a[::2]

def list11():
    a = [8, 9, 10, 11, 12, 13, 14]
    return a[1::2]

def list12():
    a = [8, 9, 10, 11, 12, 13, 14]
    return a[:4:2]

print(list1(4))
print(list1(5))
print(list2())
print(list3())
print(list4())
print(list5())
print(list6())
print(list7())
print(list8())
print(list9())
print(list10())
print(list11())
print(list12())
-- [ruby] -----------
$ py2rb tests/basic/list2.py
def list1(n)
  a = []
  a.push(1)
  a.push(2)
  a.push(3)
  a.push(n)
  return ((a[0] + a[1]) + a[2]) + a[3]
end
def list2()
  a = 5.times.to_a
  return a.to_s
end
def list3()
  a = 5.times.to_a
  a[0] = 5
  a[4] = 0
  return a.to_s
end
def list4()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[2...4]
end
def list5()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[0...4]
end
def list6()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[1...6].each_slice(2).map(&:first)
end
def list7()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[0..-1]
end
def list8()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[0..-1]
end
def list9()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[4..-1]
end
def list10()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[0..-1].each_slice(2).map(&:first)
end
def list11()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[1..-1].each_slice(2).map(&:first)
end
def list12()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[0...4].each_slice(2).map(&:first)
end
print(list1(4))
print(list1(5))
print(list2())
print(list3())
print(list4())
print(list5())
print(list6())
print(list7())
print(list8())
print(list9())
print(list10())
print(list11())
print(list12())

-- [python] ---------
* tests/basic/list3.py

x = list()
x.append('foo')
print(len(x))
print(x[0])

y = list('foo')
y.append('bar')
print(len(y))
print(y[0])
print(y[1])

z = [0, 1, 2]
print(z)
z = list(z)
print(z)
-- [ruby] -----------
$ py2rb tests/basic/list3.py
x = []
x.push("foo")
print(x.size)
print(x[0])
y = "foo".split('')
y.push("bar")
print(y.size)
print(y[0])
print(y[1])
z = [0, 1, 2]
print(z)
z = z.to_a
print(z)

-- [python] ---------
* tests/basic/listcomp1.py
a = [1,2]
[print("b:%s" % b) for b in a]
a = [(1,2) ,(2,4)]
[print("b:%s c:%s" % (b,c)) for b, c in a]
a = [(1,2,3) ,(2,4,6)]
[print("b:%s c:%s d:%s" % (b,c,d)) for b, c, d in a]
-- [ruby] -----------
$ py2rb tests/basic/listcomp1.py
a = [1, 2]
a.map{|b| print("b:%s" % b)}
a = [[1, 2], [2, 4]]
a.map{|b, c| print("b:%s c:%s" % [b, c])}
a = [[1, 2, 3], [2, 4, 6]]
a.map{|b, c, d| print("b:%s c:%s d:%s" % [b, c, d])}

-- [python] ---------
* tests/basic/literals.py

a = 1.234
b = 3
c = 3.45
d = 'cats'

print(a)
print(b)
print(c)
print(d)
-- [ruby] -----------
$ py2rb tests/basic/literals.py
a = 1.234
b = 3
c = 3.45
d = "cats"
print(a)
print(b)
print(c)
print(d)

-- [python] ---------
* tests/basic/logicalops.py

x = True
y = False
z = not y

if x:
    print('x')
if y:
    print('y')
if z:
    print('z')
-- [ruby] -----------
$ py2rb tests/basic/logicalops.py
x = true
y = false
z = !y
if is_bool(x)
  print("x")
end
if is_bool(y)
  print("y")
end
if is_bool(z)
  print("z")
end

-- [python] ---------
* tests/basic/loops.py
def loop1(x):
    a = 0
    for i in range(x):
        x
        a += i
    return a

print(loop1(1))
print(loop1(2))
print(loop1(3))
print(loop1(4))
print(loop1(5))
print(loop1(6))
print(loop1(7))
-- [ruby] -----------
$ py2rb tests/basic/loops.py
def loop1(x)
  a = 0
  for i in x.times
    x
    a += i
  end
  return a
end
print(loop1(1))
print(loop1(2))
print(loop1(3))
print(loop1(4))
print(loop1(5))
print(loop1(6))
print(loop1(7))

-- [python] ---------
* tests/basic/multiassign.py

x,y,z = (1,2,3)

print(x,y,z)
-- [ruby] -----------
$ py2rb tests/basic/multiassign.py
x,y,z = [1, 2, 3]
print(x, y, z)

-- [python] ---------
* tests/basic/none.py

x = None

if x == None:
    print("x is None/null")
else:
    print("x is not None/null")
-- [ruby] -----------
$ py2rb tests/basic/none.py
x = nil
if x == nil
  print("x is None/null")
else
  print("x is not None/null")
end

-- [python] ---------
* tests/basic/numeric.py
print(int(2.0))
print(float(2))
print(abs(-2.0))
print(abs(-2))
print(bin(254).replace('0b', ''))
print(oct(254).replace('0o', ''))
print(hex(254).replace('0x', ''))
print(hex(-36).replace('0x', ''))
-- [ruby] -----------
$ py2rb tests/basic/numeric.py
print(2.0.to_i)
print(2.to_f)
print((-2.0).abs)
print((-2).abs)
print(254.to_s(2).gsub("0b", ""))
print(254.to_s(8).gsub("0o", ""))
print(254.to_s(16).gsub("0x", ""))
print(((-36).to_s(16)).gsub("0x", ""))

-- [python] ---------
* tests/basic/oo.py

class foo(object):
    
    registered = []

    def __init__(self,val):
        self.fval = val
        self.register(self)

    def inc(self):
        self.fval += 1

    def msg(self):
        return "foo says:"+str(self.fval)

    @staticmethod
    def register(f):
        foo.registered.append(f)

    @staticmethod
    def printregistered():
        for r in foo.registered:
            print(r.msg())

a = foo(10)
b = foo(20)
c = foo(30)

a.inc()
a.inc()
c.inc()

print(a.msg())
print(b.msg())
print(c.msg())

print("---")

foo.printregistered()
-- [ruby] -----------
$ py2rb tests/basic/oo.py
class Foo
  def method_missing(method, *args)
    self.class.__send__ method, *args
  end
  @@registered = []
  def initialize(val)
    @fval = val
    Foo.register(self)
  end
  def inc()
    @fval += 1
  end
  def msg()
    return "foo says:" + @fval.to_s
  end
  def self.register(f)
    @@registered.push(f)
  end
  def self.printregistered()
    for r in @@registered
      print(r.msg())
    end
  end
  def self.registered; @@registered; end
  def self.registered=(val); @@registered=val; end
  def registered; @registered = @@registered if @registered.nil?; @registered; end
  def registered=(val); @registered=val; end
end
a = Foo.new(10)
b = Foo.new(20)
c = Foo.new(30)
a.inc()
a.inc()
c.inc()
print(a.msg())
print(b.msg())
print(c.msg())
print("---")
Foo.printregistered()

-- [python] ---------
* tests/basic/oo_attributes.py
class Foobar(object):
    foo = 1
    bar = [1, 2, 3]

my_foobar = Foobar()
print(my_foobar.foo)
print(my_foobar.bar)
print(Foobar.foo)
print(Foobar.bar)
my_foobar.foo = 2
my_foobar.bar.append(5)
print(my_foobar.foo)
print(my_foobar.bar)
print(Foobar.foo)
print(Foobar.bar)
Foobar.foo = 3
Foobar.bar.append(6)
print(my_foobar.foo)
print(my_foobar.bar)
print(Foobar.foo)
print(Foobar.bar)
-- [ruby] -----------
$ py2rb tests/basic/oo_attributes.py
class Foobar
  @@foo = 1
  @@bar = [1, 2, 3]
  def self.foo; @@foo; end
  def self.foo=(val); @@foo=val; end
  def foo; @foo = @@foo if @foo.nil?; @foo; end
  def foo=(val); @foo=val; end
  def self.bar; @@bar; end
  def self.bar=(val); @@bar=val; end
  def bar; @bar = @@bar if @bar.nil?; @bar; end
  def bar=(val); @bar=val; end
end
my_foobar = Foobar.new()
print(my_foobar.foo)
print(my_foobar.bar)
print(Foobar.foo)
print(Foobar.bar)
my_foobar.foo = 2
my_foobar.bar.push(5)
print(my_foobar.foo)
print(my_foobar.bar)
print(Foobar.foo)
print(Foobar.bar)
Foobar.foo = 3
Foobar.bar.push(6)
print(my_foobar.foo)
print(my_foobar.bar)
print(Foobar.foo)
print(Foobar.bar)

-- [python] ---------
* tests/basic/oo_inherit.py

class bar(object):

    def __init__(self,name):
        self.name = name

    def setname(self,name):
        self.name = name

class foo(bar):
    
    registered = []

    def __init__(self,val,name):
        self.fval = val
        self.register(self)
        bar.__init__(self,name)

    def inc(self):
        self.fval += 1

    def msg(self,*varargs):
        txt = ''
        for arg in varargs:
            txt += str(arg)
            txt += ","
        return txt + self.name + " says:"+str(self.fval)

    @staticmethod
    def register(f):
        foo.registered.append(f)

    @staticmethod
    def printregistered():
        for r in foo.registered:
            print(r.msg())

a = foo(10,'a')
a.setname('aaa')
b = foo(20,'b')
c = foo(30,'c')

a.inc()
a.inc()
c.inc()

print(a.msg())
print(b.msg())
print(c.msg(2,3,4))

print("---")

foo.printregistered()
-- [ruby] -----------
$ py2rb tests/basic/oo_inherit.py
class Bar
  def initialize(name)
    @name = name
  end
  def setname(name)
    @name = name
  end
end
class Foo < Bar
  def method_missing(method, *args)
    self.class.__send__ method, *args
  end
  @@registered = []
  def initialize(val, name)
    @fval = val
    Foo.register(self)
    super(name)
  end
  def inc()
    @fval += 1
  end
  def msg(*varargs)
    txt = ""
    for arg in varargs
      txt += arg.to_s
      txt += ","
    end
    return ((txt + @name) + " says:") + @fval.to_s
  end
  def self.register(f)
    @@registered.push(f)
  end
  def self.printregistered()
    for r in @@registered
      print(r.msg())
    end
  end
  def self.registered; @@registered; end
  def self.registered=(val); @@registered=val; end
  def registered; @registered = @@registered if @registered.nil?; @registered; end
  def registered=(val); @registered=val; end
end
a = Foo.new(10, "a")
a.setname("aaa")
b = Foo.new(20, "b")
c = Foo.new(30, "c")
a.inc()
a.inc()
c.inc()
print(a.msg())
print(b.msg())
print(c.msg(2, 3, 4))
print("---")
Foo.printregistered()

-- [python] ---------
* tests/basic/oo_inherit2.py
def show(o):
    """
    This tests that the proper method is called.
    """
    o.msg()

def show2(o):
    """
    This tests oo inheritance.
    """
    o.print_msg()

class A(object):

    def msg(self):
        print("A.msg()")

    def print_msg(self):
        self.msg()

class B(A):

    def msg(self):
        print("B.msg()")


a = A()
show(a)
show2(a)
b = B()
show(b)
show2(b)
-- [ruby] -----------
$ py2rb tests/basic/oo_inherit2.py
def show(o)
  # 
  #   This tests that the proper method is called.
  #   
  o.msg()
end
def show2(o)
  # 
  #   This tests oo inheritance.
  #   
  o.print_msg()
end
class A
  def msg()
    print("A.msg()")
  end
  def print_msg()
    msg()
  end
end
class B < A
  def msg()
    print("B.msg()")
  end
end
a = A.new()
show(a)
show2(a)
b = B.new()
show(b)
show2(b)

-- [python] ---------
* tests/basic/oo_inherit3.py
def show(o):
    """
    This tests that the proper method is called.
    """
    o.msg()

def show2(o):
    """
    This tests oo inheritance.
    """
    o.print_msg()

class A(object):

    def __init__(self):
        self._a = 5

    def msg(self):
        print("A.msg()")

    def print_msg(self):
        self.msg()
        print(self._a)

class B(A):

    def msg(self):
        print("B.msg()")


a = A()
show(a)
show2(a)
b = B()
show(b)
show2(b)
-- [ruby] -----------
$ py2rb tests/basic/oo_inherit3.py
def show(o)
  # 
  #   This tests that the proper method is called.
  #   
  o.msg()
end
def show2(o)
  # 
  #   This tests oo inheritance.
  #   
  o.print_msg()
end
class A
  def initialize()
    @_a = 5
  end
  def msg()
    print("A.msg()")
  end
  def print_msg()
    msg()
    print(@_a)
  end
end
class B < A
  def msg()
    print("B.msg()")
  end
end
a = A.new()
show(a)
show2(a)
b = B.new()
show(b)
show2(b)

-- [python] ---------
* tests/basic/oo_inherit_simple.py

class bar(object):

    def __init__(self,name):
        self.name = name

    def setname(self,name):
        self.name = name

class foo(bar):
    
    registered = []

    def __init__(self,val,name):
        self.fval = val
        self.register(self)
        self.name = name

    def inc(self):
        self.fval += 1

    def msg(self, a=None, b=None, c=None):
        txt = ''
        varargs = a, b, c
        for arg in varargs:
            if arg is None:
                continue
            txt += str(arg)
            txt += ","
        return txt + self.name + " says:"+str(self.fval)

    @staticmethod
    def register(f):
        foo.registered.append(f)

    @staticmethod
    def printregistered():
        for r in foo.registered:
            print(r.msg())

a = foo(10,'a')
a.setname('aaa')
b = foo(20,'b')
c = foo(30,'c')

a.inc()
a.inc()
c.inc()

print(a.msg())
print(b.msg())
print(c.msg(2,3,4))

print("---")

foo.printregistered()
-- [ruby] -----------
$ py2rb tests/basic/oo_inherit_simple.py
class Bar
  def initialize(name)
    @name = name
  end
  def setname(name)
    @name = name
  end
end
class Foo < Bar
  def method_missing(method, *args)
    self.class.__send__ method, *args
  end
  @@registered = []
  def initialize(val, name)
    @fval = val
    Foo.register(self)
    @name = name
  end
  def inc()
    @fval += 1
  end
  def msg(a: nil, b: nil, c: nil)
    txt = ""
    varargs = [a, b, c]
    for arg in varargs
      if arg === nil
        next
      end
      txt += arg.to_s
      txt += ","
    end
    return ((txt + @name) + " says:") + @fval.to_s
  end
  def self.register(f)
    @@registered.push(f)
  end
  def self.printregistered()
    for r in @@registered
      print(r.msg())
    end
  end
  def self.registered; @@registered; end
  def self.registered=(val); @@registered=val; end
  def registered; @registered = @@registered if @registered.nil?; @registered; end
  def registered=(val); @registered=val; end
end
a = Foo.new(10, "a")
a.setname("aaa")
b = Foo.new(20, "b")
c = Foo.new(30, "c")
a.inc()
a.inc()
c.inc()
print(a.msg())
print(b.msg())
print(c.msg(a: 2, b: 3, c: 4))
print("---")
Foo.printregistered()

-- [python] ---------
* tests/basic/oo_inherit_simple_super1.py

class bar(object):

    def __init__(self,name):
        self.name = name

    def setname(self,name):
        self.name = name

class foo(bar):
    
    registered = []

    def __init__(self,val,name):
        self.fval = val
        self.register(self)
        bar.__init__(self,name)

    def inc(self):
        self.fval += 1

    def msg(self, a=None, b=None, c=None):
        txt = ''
        varargs = a, b, c
        for arg in varargs:
            if arg is None:
                continue
            txt += str(arg)
            txt += ","
        return txt + self.name + " says:"+str(self.fval)

    @staticmethod
    def register(f):
        foo.registered.append(f)

    @staticmethod
    def printregistered():
        for r in foo.registered:
            print(r.msg())

a = foo(10,'a')
a.setname('aaa')
b = foo(20,'b')
c = foo(30,'c')

a.inc()
a.inc()
c.inc()

print(a.msg())
print(b.msg())
print(c.msg(2,3,4))

print("---")

foo.printregistered()
-- [ruby] -----------
$ py2rb tests/basic/oo_inherit_simple_super1.py
class Bar
  def initialize(name)
    @name = name
  end
  def setname(name)
    @name = name
  end
end
class Foo < Bar
  def method_missing(method, *args)
    self.class.__send__ method, *args
  end
  @@registered = []
  def initialize(val, name)
    @fval = val
    Foo.register(self)
    super(name)
  end
  def inc()
    @fval += 1
  end
  def msg(a: nil, b: nil, c: nil)
    txt = ""
    varargs = [a, b, c]
    for arg in varargs
      if arg === nil
        next
      end
      txt += arg.to_s
      txt += ","
    end
    return ((txt + @name) + " says:") + @fval.to_s
  end
  def self.register(f)
    @@registered.push(f)
  end
  def self.printregistered()
    for r in @@registered
      print(r.msg())
    end
  end
  def self.registered; @@registered; end
  def self.registered=(val); @@registered=val; end
  def registered; @registered = @@registered if @registered.nil?; @registered; end
  def registered=(val); @registered=val; end
end
a = Foo.new(10, "a")
a.setname("aaa")
b = Foo.new(20, "b")
c = Foo.new(30, "c")
a.inc()
a.inc()
c.inc()
print(a.msg())
print(b.msg())
print(c.msg(a: 2, b: 3, c: 4))
print("---")
Foo.printregistered()

-- [python] ---------
* tests/basic/oo_inherit_simple_super2.py

class bar(object):

    def __init__(self,name):
        self.name = name

    def setname(self,name):
        self.name = name

class foo(bar):
    
    registered = []

    def __init__(self,val,name):
        self.fval = val
        self.register(self)
        super(foo, self).__init__(name)

    def inc(self):
        self.fval += 1

    def msg(self, a=None, b=None, c=None):
        txt = ''
        varargs = a, b, c
        for arg in varargs:
            if arg is None:
                continue
            txt += str(arg)
            txt += ","
        return txt + self.name + " says:"+str(self.fval)

    @staticmethod
    def register(f):
        foo.registered.append(f)

    @staticmethod
    def printregistered():
        for r in foo.registered:
            print(r.msg())

a = foo(10,'a')
a.setname('aaa')
b = foo(20,'b')
c = foo(30,'c')

a.inc()
a.inc()
c.inc()

print(a.msg())
print(b.msg())
print(c.msg(2,3,4))

print("---")

foo.printregistered()
-- [ruby] -----------
$ py2rb tests/basic/oo_inherit_simple_super2.py
class Bar
  def initialize(name)
    @name = name
  end
  def setname(name)
    @name = name
  end
end
class Foo < Bar
  def method_missing(method, *args)
    self.class.__send__ method, *args
  end
  @@registered = []
  def initialize(val, name)
    @fval = val
    Foo.register(self)
    super(name)
  end
  def inc()
    @fval += 1
  end
  def msg(a: nil, b: nil, c: nil)
    txt = ""
    varargs = [a, b, c]
    for arg in varargs
      if arg === nil
        next
      end
      txt += arg.to_s
      txt += ","
    end
    return ((txt + @name) + " says:") + @fval.to_s
  end
  def self.register(f)
    @@registered.push(f)
  end
  def self.printregistered()
    for r in @@registered
      print(r.msg())
    end
  end
  def self.registered; @@registered; end
  def self.registered=(val); @@registered=val; end
  def registered; @registered = @@registered if @registered.nil?; @registered; end
  def registered=(val); @registered=val; end
end
a = Foo.new(10, "a")
a.setname("aaa")
b = Foo.new(20, "b")
c = Foo.new(30, "c")
a.inc()
a.inc()
c.inc()
print(a.msg())
print(b.msg())
print(c.msg(a: 2, b: 3, c: 4))
print("---")
Foo.printregistered()

-- [python] ---------
* tests/basic/oo_inherit_simple_super3.py

class bar(object):

    def __init__(self,name):
        self.name = name

    def setname(self,name):
        self.name = name

class foo(bar):
    
    registered = []

    def __init__(self,val,name):
        self.fval = val
        self.register(self)
        super().__init__(name)

    def inc(self):
        self.fval += 1

    def msg(self, a=None, b=None, c=None):
        txt = ''
        varargs = a, b, c
        for arg in varargs:
            if arg is None:
                continue
            txt += str(arg)
            txt += ","
        return txt + self.name + " says:"+str(self.fval)

    @staticmethod
    def register(f):
        foo.registered.append(f)

    @staticmethod
    def printregistered():
        for r in foo.registered:
            print(r.msg())

a = foo(10,'a')
a.setname('aaa')
b = foo(20,'b')
c = foo(30,'c')

a.inc()
a.inc()
c.inc()

print(a.msg())
print(b.msg())
print(c.msg(2,3,4))

print("---")

foo.printregistered()
-- [ruby] -----------
$ py2rb tests/basic/oo_inherit_simple_super3.py
class Bar
  def initialize(name)
    @name = name
  end
  def setname(name)
    @name = name
  end
end
class Foo < Bar
  def method_missing(method, *args)
    self.class.__send__ method, *args
  end
  @@registered = []
  def initialize(val, name)
    @fval = val
    Foo.register(self)
    super(name)
  end
  def inc()
    @fval += 1
  end
  def msg(a: nil, b: nil, c: nil)
    txt = ""
    varargs = [a, b, c]
    for arg in varargs
      if arg === nil
        next
      end
      txt += arg.to_s
      txt += ","
    end
    return ((txt + @name) + " says:") + @fval.to_s
  end
  def self.register(f)
    @@registered.push(f)
  end
  def self.printregistered()
    for r in @@registered
      print(r.msg())
    end
  end
  def self.registered; @@registered; end
  def self.registered=(val); @@registered=val; end
  def registered; @registered = @@registered if @registered.nil?; @registered; end
  def registered=(val); @registered=val; end
end
a = Foo.new(10, "a")
a.setname("aaa")
b = Foo.new(20, "b")
c = Foo.new(30, "c")
a.inc()
a.inc()
c.inc()
print(a.msg())
print(b.msg())
print(c.msg(a: 2, b: 3, c: 4))
print("---")
Foo.printregistered()

-- [python] ---------
* tests/basic/oo_static_inherit.py


class A1(object):
    
    @staticmethod
    def msg(val):
        print("A1 static method msg says:"+str(val))

class A2(A1):
    pass

a = A2()

a.msg("hello")
A2.msg("world")
-- [ruby] -----------
$ py2rb tests/basic/oo_static_inherit.py
class A1
  def method_missing(method, *args)
    self.class.__send__ method, *args
  end
  def self.msg(val)
    print("A1 static method msg says:" + val.to_s)
  end
end
class A2 < A1
  # pass
end
a = A2.new()
a.msg("hello")
A2.msg("world")

-- [python] ---------
* tests/basic/pass.py

x = 'hello'

if x != 'hello':
    print("1")
    pass
    print("2")
else:
    print("3")
    pass
    print("4")


-- [ruby] -----------
$ py2rb tests/basic/pass.py
x = "hello"
if x != "hello"
  print("1")
  # pass
  print("2")
else
  print("3")
  # pass
  print("4")
end

-- [python] ---------
* tests/basic/print.py
print(1.23, "foobar", -1, 'x')

-- [ruby] -----------
$ py2rb tests/basic/print.py
print(1.23, "foobar", -1, "x")

-- [python] ---------
* tests/basic/raise.py


a = "hello"

try:
    try:
        print("Trying illegal access")
        x = "abc"
        x.abc()
    except:
        print("Exception raised, re-raising")
        raise
except:
    print("Exception raised")
    pass
-- [ruby] -----------
$ py2rb tests/basic/raise.py
a = "hello"
begin
  begin
    print("Trying illegal access")
    x = "abc"
    x.abc()
  rescue
    print("Exception raised, re-raising")
    raise
  end
rescue
  print("Exception raised")
  # pass
end

-- [python] ---------
* tests/basic/raise2.py
try:
    raise
except:
    pass

try:
    foo
except NameError:
    print('NameError :')
except:
    print('Error :')

try:
    raise NameError
except NameError:
    print('NameError :')
except:
    print('Error :')

try:
    raise NameError('User Defined Error Message.')
except NameError as err:
    print('NameError :', err)
except:
    print('Error :')

try:
    raise NotImplementedError('User Defined Error Message.')
except NotImplementedError as err:
    print('NotImplementedError :', err)
except:
    print('Error :')
-- [ruby] -----------
$ py2rb tests/basic/raise2.py
begin
  raise
rescue
  # pass
end
begin
  foo
rescue NameError
  print("NameError :")
rescue
  print("Error :")
end
begin
  raise NameError
rescue NameError
  print("NameError :")
rescue
  print("Error :")
end
begin
  raise NameError, "User Defined Error Message."
rescue NameError => err
  print("NameError :", err)
rescue
  print("Error :")
end
begin
  raise NotImplementedError, "User Defined Error Message."
rescue NotImplementedError => err
  print("NotImplementedError :", err)
rescue
  print("Error :")
end

-- [python] ---------
* tests/basic/scope.py

x = 12

def loopy():
    for x in range(0,8):
        print(x)

loopy()
print(x)
-- [ruby] -----------
$ py2rb tests/basic/scope.py
x = 12
def loopy()
  for x in 0.upto(8-1)
    print(x)
  end
end
loopy()
print(x)

-- [python] ---------
* tests/basic/set.py
# iterating over a list
print('-- set --')
a = set([1,2,3,4,5])
a.remove(3)
for x in a:
    print(x)

print('-- set add --')
a = set()
a.add(1)
a.add(2)
a.add(1)
for x in a:
    print(x)

print('-- set clear --')

a.clear() 
for x in a:
    print(x)
-- [ruby] -----------
$ py2rb tests/basic/set.py
print("-- set --")
a = Set.new([1, 2, 3, 4, 5])
a.remove(3)
for x in a
  print(x)
end
print("-- set add --")
a = Set.new()
a.add(1)
a.add(2)
a.add(1)
for x in a
  print(x)
end
print("-- set clear --")
a.clear()
for x in a
  print(x)
end

-- [python] ---------
* tests/basic/str1.py
s1 = "some string"

s2 = "some 'x' string"

s3 = 'some "x" string'

s4 = "some \"x\" string"

s5 = """some "x" string"""

s6 = """some "x" string
and some other string too...
"""

if s2 == s3:
    print("ok1")
if s3 == s4:
    print("ok2")
if s3 == s5:
    print("ok3")
if s3 != s6:
    print("ok4")

"""some "x" string
and some other string too...
"""

if True:
    """some "x" string
    and some other string too...
    """
-- [ruby] -----------
$ py2rb tests/basic/str1.py
s1 = "some string"
s2 = "some 'x' string"
s3 = "some \"x\" string"
s4 = "some \"x\" string"
s5 = "some \"x\" string"
s6 = "some \"x\" string
and some other string too...
"
if s2 == s3
  print("ok1")
end
if s3 == s4
  print("ok2")
end
if s3 == s5
  print("ok3")
end
if s3 != s6
  print("ok4")
end
# some \"x\" string
# and some other string too...
# 
if true
  # some \"x\" string
  #   and some other string too...
  #   
end

-- [python] ---------
* tests/basic/str_endswith.py
if 'hoge.txt'.endswith('.txt'):
    print('OK')
else:
    print('NG')
-- [ruby] -----------
$ py2rb tests/basic/str_endswith.py
if is_bool("hoge.txt".end_with?(".txt"))
  print("OK")
else
  print("NG")
end

-- [python] ---------
* tests/basic/sumcomp.py


x = sum(x*x for x in [2,3,4,5,6,7])
print(x)
-- [ruby] -----------
$ py2rb tests/basic/sumcomp.py
x = ([2, 3, 4, 5, 6, 7].map{|x| x * x}).sum
print(x)

-- [python] ---------
* tests/basic/super1.py


class baseklass(object):

    def __init__(self,bval):
        self.bval = bval

    def describe(self,arg):
        print("baseklass.describe:"+self.bval+":"+str(arg))

    def describe2(self,**kwargs):
        print("baseklass.describe2:"+self.bval+":"+kwargs['string'])

class klass(baseklass):
    
    def __init__(self,val,bval):
        baseklass.__init__(self,bval)
        self.val = val

    def describe(self):
        super(klass,self).describe(10)
        super(klass,self).describe2(string='somestring')
        self.describe2(string='somestring')
        print("klass.describe:"+self.val)

k = klass("world","hello")
k.describe()
-- [ruby] -----------
$ py2rb tests/basic/super1.py
class Baseklass
  def initialize(bval)
    @bval = bval
  end
  def describe(arg)
    print((("baseklass.describe:" + @bval) + ":") + arg.to_s)
  end
  def describe2(**kwargs)
    print((("baseklass.describe2:" + @bval) + ":") + kwargs[:string])
  end
end
class Klass < Baseklass
  def initialize(val, bval)
    super(bval)
    @val = val
  end
  def describe()
    super(10)
    describe2(string: "somestring")
    describe2(string: "somestring")
    print("klass.describe:" + @val)
  end
end
k = Klass.new("world", "hello")
k.describe()

-- [python] ---------
* tests/basic/super2.py


class baseklass(object):

    def __init__(self,bval):
        self.bval = bval

    def describe(self,arg):
        print("baseklass.describe:"+self.bval+":"+str(arg))

    def describe2(self,**kwargs):
        print("baseklass.describe2:"+self.bval+":"+kwargs['string'])
        print("baseklass.describe2:"+self.bval+":"+kwargs['string2'])
        kwargs['string2'] = kwargs['string3']
        print("baseklass.describe2:"+self.bval+":"+kwargs['string2'])

class klass(baseklass):
    
    def __init__(self,val,bval):
        baseklass.__init__(self,bval)
        self.val = val

    def describe(self):
        super(klass,self).describe(10)
        super(klass,self).describe2(string='somestring', string2='anystring', string3='changestring')
        print("klass.describe:"+self.val)

    def describe2(self,**kwargs):
        print("klass.describe2:"+self.bval+":"+kwargs['string'])

k = klass("world","hello")
k.describe()
-- [ruby] -----------
$ py2rb tests/basic/super2.py
class Baseklass
  def initialize(bval)
    @bval = bval
  end
  def describe(arg)
    print((("baseklass.describe:" + @bval) + ":") + arg.to_s)
  end
  def describe2(**kwargs)
    print((("baseklass.describe2:" + @bval) + ":") + kwargs[:string])
    print((("baseklass.describe2:" + @bval) + ":") + kwargs[:string2])
    kwargs[:string2] = kwargs[:string3]
    print((("baseklass.describe2:" + @bval) + ":") + kwargs[:string2])
  end
end
class Klass < Baseklass
  def initialize(val, bval)
    super(bval)
    @val = val
  end
  def describe()
    super(10)
    public_method(:describe2).super_method.call(string: "somestring", string2: "anystring", string3: "changestring")
    print("klass.describe:" + @val)
  end
  def describe2(**kwargs)
    print((("klass.describe2:" + @bval) + ":") + kwargs[:string])
  end
end
k = Klass.new("world", "hello")
k.describe()

-- [python] ---------
* tests/basic/trueorfalse.py

literals = ['a','',0,None,1,0.0,1.0,-1,-1.0,-0]

for l in literals:
    if l:
        print("True")
    else:
        print("False")
-- [ruby] -----------
$ py2rb tests/basic/trueorfalse.py
literals = ["a", "", 0, nil, 1, 0.0, 1.0, -1, -1.0, -0]
for l in literals
  if is_bool(l)
    print("True")
  else
    print("False")
  end
end

-- [python] ---------
* tests/basic/try.py

class MyException(Exception):

    def __init__(self,msg):
        self.msg = msg

    def message(self):
        return self.msg

class MyOtherException(Exception):

    def __init__(self,msg):
        self.msg = msg

    def message(self):
        return self.msg

for index in [1,2]:
    try:
        print('raising exception...')
        if index==1:
            raise MyException('bar')
        elif index==2:
            raise MyOtherException('foo')
    except MyOtherException as ex2:
        print('caught other exception:' + ex2.message())
    except MyException as ex:
        print('caught exception:' + ex.message())
    finally:
        print('and finally...')
-- [ruby] -----------
$ py2rb tests/basic/try.py
class MyException < Exception
  def initialize(msg)
    @msg = msg
  end
  def message()
    return @msg
  end
end
class MyOtherException < Exception
  def initialize(msg)
    @msg = msg
  end
  def message()
    return @msg
  end
end
for index in [1, 2]
  begin
    print("raising exception...")
    if index == 1
      raise MyException, "bar"
    else
      if index == 2
        raise MyOtherException, "foo"
      end
    end
  rescue MyOtherException => ex2
    print("caught other exception:" + ex2.message())
  rescue MyException => ex
    print("caught exception:" + ex.message())
  ensure
    print("and finally...")
  end
end

-- [python] ---------
* tests/basic/tuple.py

tup = ('a','b',1,2,3)
print(len(tup))
print(tup[0])
print(tup[1])
print(tup[2])
print(tup[3])
print(tup[4])

tup = tuple()
print(len(tup))

tup = tuple(('a','b',1,2,3))
print(len(tup))
print(tup[0])
print(tup[1])
print(tup[2])
print(tup[3])

tup = tuple("ABC")
print(len(tup))
print(tup[0])
print(tup[1])
print(tup[2])

tup = tuple([10, 20])
print(len(tup))
print(tup[0])
print(tup[1])
-- [ruby] -----------
$ py2rb tests/basic/tuple.py
tup = ["a", "b", 1, 2, 3]
print(tup.size)
print(tup[0])
print(tup[1])
print(tup[2])
print(tup[3])
print(tup[4])
tup = []
print(tup.size)
tup = ["a", "b", 1, 2, 3].to_a
print(tup.size)
print(tup[0])
print(tup[1])
print(tup[2])
print(tup[3])
tup = "ABC".split('')
print(tup.size)
print(tup[0])
print(tup[1])
print(tup[2])
tup = [10, 20].to_a
print(tup.size)
print(tup[0])
print(tup[1])

-- [python] ---------
* tests/basic/tuple2.py
def tuple1(x):
    t = (x, x+1, x+2)
    a, b, c = t
    return a+b+c

def tuple2(n):
    a = 0
    for i in (1, 2, n):
        a += i
    return a

def tuple3():
    a = (1, 3, 5, 4, 9, 1, 2, 3)
    return len(a)

def tuple4(n):
    a = (1, 3, 3, 4, 9, 1, 2, 3)
    return a.count(n)

def tuple5(n):
    a = (1, 3, 3, 4, 9, 1, 2, 3)
    return a.index(n)

def tuple6():
    a = (8, 9, 10, 11, 12, 13, 14)
    return a[2:4]

def tuple7():
    a = (8, 9, 10, 11, 12, 13, 14)
    return a[:4]

def tuple8():
    a = (8, 9, 10, 11, 12, 13, 14)
    return a[1:6:2]

def tuple9():
    a = (8, 9, 10, 11, 12, 13, 14)
    return a[:]

def tuple10():
    a = (8, 9, 10, 11, 12, 13, 14)
    return a[4:]


print(tuple1(3))
print(tuple2(3))
print(tuple2(4))
print(tuple3())
print(tuple4(1))
print(tuple4(3))
print(tuple4(4))
print(tuple4(5))
print(tuple5(1))
print(tuple5(4))
print(tuple6())
print(tuple7())
print(tuple8())
print(tuple9())
print(tuple10())
-- [ruby] -----------
$ py2rb tests/basic/tuple2.py
def tuple1(x)
  t = [x, x + 1, x + 2]
  a,b,c = t
  return (a + b) + c
end
def tuple2(n)
  a = 0
  for i in [1, 2, n]
    a += i
  end
  return a
end
def tuple3()
  a = [1, 3, 5, 4, 9, 1, 2, 3]
  return a.size
end
def tuple4(n)
  a = [1, 3, 3, 4, 9, 1, 2, 3]
  return a.count(n)
end
def tuple5(n)
  a = [1, 3, 3, 4, 9, 1, 2, 3]
  return a.index(n)
end
def tuple6()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[2...4]
end
def tuple7()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[0...4]
end
def tuple8()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[1...6].each_slice(2).map(&:first)
end
def tuple9()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[0..-1]
end
def tuple10()
  a = [8, 9, 10, 11, 12, 13, 14]
  return a[4..-1]
end
print(tuple1(3))
print(tuple2(3))
print(tuple2(4))
print(tuple3())
print(tuple4(1))
print(tuple4(3))
print(tuple4(4))
print(tuple4(5))
print(tuple5(1))
print(tuple5(4))
print(tuple6())
print(tuple7())
print(tuple8())
print(tuple9())
print(tuple10())

-- [python] ---------
* tests/basic/vargs.py

def myfunc(a,b,*c):
    print(a)
    print(b)
    for i in c:
        print(i)

myfunc(1,2)
myfunc('a','b','c','d')
myfunc(3,4,5,6,'hello')

-- [ruby] -----------
$ py2rb tests/basic/vargs.py
def myfunc(a, b, *c)
  print(a)
  print(b)
  for i in c
    print(i)
  end
end
myfunc(1, 2)
myfunc("a", "b", "c", "d")
myfunc(3, 4, 5, 6, "hello")

-- [python] ---------
* tests/basic/while.py
""" while case """
x = 1
while x<10:
    print(x)
    x = x + 1

""" while and else case """
x = 1
while x<10:
    print(x)
    x = x + 1
else:
    print("ok")
""" while and else break case """
x = 1
while x<10:
    print(x)
    x = x + 1
    break
else:
    print("ok")
-- [ruby] -----------
$ py2rb tests/basic/while.py
#  while case 
x = 1
while x < 10
  print(x)
  x = x + 1
end
#  while and else case 
x = 1
__dummy0__ = false
while true
    unless x < 10
        __dummy0__ = true
        break
    end
  print(x)
  x = x + 1
end
if __dummy0__
  print("ok")
end
#  while and else break case 
x = 1
__dummy1__ = false
while true
    unless x < 10
        __dummy1__ = true
        break
    end
  print(x)
  x = x + 1
  break
end
if __dummy1__
  print("ok")
end

-- [python] ---------
* tests/basic/with.py
with open("hello.txt", 'w') as f:
    f.write("Hello, world!")

with open("hello.txt", 'r') as f:
    print(f.read())

with open("hello.txt", 'r'):
    print('ok')
-- [ruby] -----------
$ py2rb tests/basic/with.py
open("hello.txt", "w") {|f|
  f.write("Hello, world!")
}
open("hello.txt", "r") {|f|
  print(f.read())
}
open("hello.txt", "r") {
  print("ok")
}

-- [python] ---------
* tests/collections/ordered_dict.py
import collections


d = collections.OrderedDict({'one': 1, 'two':2, 'three':3})
print(d['one'])
print(d['two'])
print(d['three'])

e = collections.OrderedDict(d)
print(e['one'])
print(e['two'])
print(e['three'])
#d = collections.OrderedDict(one=1, two=2, three=3)
#print(d['one'])
#print(d['two'])
#print(d['three'])
-- [ruby] -----------
$ py2rb tests/collections/ordered_dict.py
d = {"one" => 1, "two" => 2, "three" => 3}
print(d["one"])
print(d["two"])
print(d["three"])
e = d.dup
print(e["one"])
print(e["two"])
print(e["three"])

-- [python] ---------
* tests/decorator/function1.py

class wrapper:

    def __init__(self,fn):
        self.fn = fn

    def __call__(self,*args):
        return "(" + self.fn(*args) + ")"

def mydecorator(x):
    print("decorating " + str(x)) 
    return wrapper(x)

def describe():
    return "world"
describe = mydecorator(describe)

print(describe())
-- [ruby] -----------
$ py2rb tests/decorator/function1.py
class Wrapper
  def initialize(fn)
    @fn = fn
  end
  def call(*args)
    return ("(" + (@fn.(*args))) + ")"
  end
end
def mydecorator(x)
  print("decorating " + x.to_s)
  return Wrapper.new(x)
end
def describe()
  return "world"
end
describe = mydecorator(method(:describe))
print(describe.())

-- [python] ---------
* tests/decorator/function2.py

class wrapper:

    def __init__(self,fn):
        self.fn = fn

    def __call__(self,*args):
        return "(" + self.fn(*args) + ")"

def mydecorator(x):
    print("decorating " + str(x)) 
    return wrapper(x)

@mydecorator
def describe():
    return "world"

print(describe())
-- [ruby] -----------
$ py2rb tests/decorator/function2.py
class Wrapper
  def initialize(fn)
    @fn = fn
  end
  def call(*args)
    return ("(" + (@fn.(*args))) + ")"
  end
end
def mydecorator(x)
  print("decorating " + x.to_s)
  return Wrapper.new(x)
end
def describe()
  return "world"
end
describe = mydecorator(method(:describe))
print(describe.())

-- [python] ---------
* tests/decorator/function3.py

class wrapper:

    def __init__(self,fn):
        self.fn = fn

    def __call__(self,*args):
        return "(" + self.fn(*args) + ")"

def mydecorator(x):
    print("decorating " + str(x)) 
    return wrapper(x)

@mydecorator
def describe():
    return "world"
describe = mydecorator(describe)

print(describe())
-- [ruby] -----------
$ py2rb tests/decorator/function3.py
class Wrapper
  def initialize(fn)
    @fn = fn
  end
  def call(*args)
    return ("(" + (@fn.(*args))) + ")"
  end
end
def mydecorator(x)
  print("decorating " + x.to_s)
  return Wrapper.new(x)
end
def describe()
  return "world"
end
describe = mydecorator(method(:describe))
describe = mydecorator(describe)
print(describe.())

-- [python] ---------
* tests/decorator/property.py
class propertyDecorator(object):
    def __init__(self, x):
        self._x = x

    @property
    def x(self):
        return self._x

pd = propertyDecorator(100)
print(pd.x)

-- [ruby] -----------
$ py2rb tests/decorator/property.py
class PropertyDecorator
  def initialize(x)
    @_x = x
  end
  def x()
    return @_x
  end
end
pd = PropertyDecorator.new(100)
print(pd.x)

-- [python] ---------
* tests/decorator/setter.py
class propertyDecorator(object):
    def __init__(self, x):
        self._x = x

    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

pd = propertyDecorator(100)
print(pd.x)
pd.x = 10
print(pd.x)

-- [ruby] -----------
$ py2rb tests/decorator/setter.py
class PropertyDecorator
  def initialize(x)
    @_x = x
  end
  def x()
    return @_x
  end
  def x=(value)
    @_x = value
  end
end
pd = PropertyDecorator.new(100)
print(pd.x)
pd.x = 10
print(pd.x)

-- [python] ---------
* tests/deep-learning-from-scratch/and_gate.py
# coding: utf-8
import numpy as np


def AND(x1, x2):
    x = np.array([x1, x2])
    w = np.array([0.5, 0.5])
    b = -0.7
    tmp = np.sum(w*x) + b
    if tmp <= 0:
        return 0
    else:
        return 1

if __name__ == '__main__':
    for xs in [(0, 0), (1, 0), (0, 1), (1, 1)]:
        y = AND(xs[0], xs[1])
        print(str(xs) + " -> " + str(y))
-- [ruby] -----------
$ py2rb tests/deep-learning-from-scratch/and_gate.py
require 'numo/narray'
def AND(x1, x2)
  x = Numo::NArray.cast([x1, x2])
  w = Numo::NArray.cast([0.5, 0.5])
  b = -0.7
  tmp = ((w * x).sum()) + b
  if tmp <= 0
    return 0
  else
    return 1
  end
end
if __FILE__ == $0
  for xs in [[0, 0], [1, 0], [0, 1], [1, 1]]
    y = AND(xs[0], xs[1])
    print((xs.to_s + (" -> ")) + y.to_s)
  end
end

-- [python] ---------
* tests/deep-learning-from-scratch/relu.py
# coding: utf-8
import numpy as np

def relu(x):
    return np.maximum(0, x)

x = np.arange(-5.0, 5.0, 0.1)
y = relu(x)

def print_array(data):
    datas = []
    for i in data:
        if float("%.3f" % abs(i)) == 0:
            datas.append(float("%.3f" % abs(i)))
        else:
            datas.append(float("%.3f" % i))
    print(datas)

print(len(x))
print_array(list(x))
print(len(y))
print_array(list(y))

-- [ruby] -----------
$ py2rb tests/deep-learning-from-scratch/relu.py
require 'numo/narray'
def relu(x)
  return Numo::DFloat.maximum(0, x)
end
x = Numo::DFloat.new(((5.0-(-5.0))/(0.1).to_f).ceil).seq(-5.0, 0.1)
y = relu(x)
def print_array(data)
  datas = []
  for i in data
    if ("%.3f" % i.abs).to_f == 0
      datas.push(("%.3f" % i.abs).to_f)
    else
      datas.push(("%.3f" % i).to_f)
    end
  end
  print(datas)
end
print(x.size)
print_array(x.to_a)
print(y.size)
print_array(y.to_a)

-- [python] ---------
* tests/deep-learning-from-scratch/sigmoid.py
import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))    

x = np.arange(-5.0, 5.0, 0.1)
y = sigmoid(x)

def print_array(data):
    datas = []
    for i in data:
        if float("%.3f" % abs(i)) == 0:
            datas.append(float("%.3f" % abs(i)))
        else:
            datas.append(float("%.3f" % i))
    print(datas)

print(len(x))
print_array(list(x))

print(len(y))
print_array(list(y))
-- [ruby] -----------
$ py2rb tests/deep-learning-from-scratch/sigmoid.py
require 'numo/narray'
def sigmoid(x)
  return 1 / (1 + (Numo::NMath.exp(-x)))
end
x = Numo::DFloat.new(((5.0-(-5.0))/(0.1).to_f).ceil).seq(-5.0, 0.1)
y = sigmoid(x)
def print_array(data)
  datas = []
  for i in data
    if ("%.3f" % i.abs).to_f == 0
      datas.push(("%.3f" % i.abs).to_f)
    else
      datas.push(("%.3f" % i).to_f)
    end
  end
  print(datas)
end
print(x.size)
print_array(x.to_a)
print(y.size)
print_array(y.to_a)

-- [python] ---------
* tests/deep-learning-from-scratch/step_function.py
# coding: utf-8
import numpy as np

def step_function(x):
    return np.array(x > 0, dtype=np.int)

X = np.arange(-5.0, 5.0, 0.1)
Y = step_function(X)


def print_array(data):
    datas = []
    for i in data:
        if float("%.3f" % abs(i)) == 0:
            datas.append(float("%.3f" % abs(i)))
        else:
            datas.append(float("%.3f" % i))
    print(datas)

print(len(X))
print_array(list(X))
print(len(Y))
print_array(list(Y))
-- [ruby] -----------
$ py2rb tests/deep-learning-from-scratch/step_function.py
require 'numo/narray'
def step_function(x)
  return Numo::Int64.cast(x > 0)
end
X = Numo::DFloat.new(((5.0-(-5.0))/(0.1).to_f).ceil).seq(-5.0, 0.1)
Y = step_function(X)
def print_array(data)
  datas = []
  for i in data
    if ("%.3f" % i.abs).to_f == 0
      datas.push(("%.3f" % i.abs).to_f)
    else
      datas.push(("%.3f" % i).to_f)
    end
  end
  print(datas)
end
print(X.size)
print_array(X.to_a)
print(Y.size)
print_array(Y.to_a)

-- [python] ---------
* tests/errors/py_collision.py
a = 1
if a == 1:
    print("ok")
else:
    print("no")

py_builtins = 1
if py_builtins == 1:
    print("ok")
else:
    print("no")

for py_builtins in range(5):
    a += py_builtins

print(a)
-- [ruby] -----------
$ py2rb tests/errors/py_collision.py
a = 1
if a == 1
  print("ok")
else
  print("no")
end
py_builtins = 1
if py_builtins == 1
  print("ok")
else
  print("no")
end
for py_builtins in 5.times
  a += py_builtins
end
print(a)

-- [python] ---------
* tests/functions/and.py

tests = [(False,False),(False,True),(True,False),(True,True),(True,None),(False,None),(None,True),(None,False)]

def pp(v):
    if v == False:
        return "F"
    if v == True:
        return "T"
    return "?"

for t in tests:
    (b1,b2) = t
    print(pp(b1) + " AND " + pp(b2) + "=" + pp(b1 and b2))
-- [ruby] -----------
$ py2rb tests/functions/and.py
tests = [[false, false], [false, true], [true, false], [true, true], [true, nil], [false, nil], [nil, true], [nil, false]]
def pp(v)
  if v == false
    return "F"
  end
  if v == true
    return "T"
  end
  return "?"
end
for t in tests
  b1,b2 = t
  print((((pp(b1) + " AND ") + pp(b2)) + "=") + pp(b1 && b2))
end

-- [python] ---------
* tests/functions/append.py

mylist = []
mylist.append('a')
mylist.append('b')
mylist.append('c')

print(mylist[0])
print(mylist[1])
print(mylist[2])
-- [ruby] -----------
$ py2rb tests/functions/append.py
mylist = []
mylist.push("a")
mylist.push("b")
mylist.push("c")
print(mylist[0])
print(mylist[1])
print(mylist[2])

-- [python] ---------
* tests/functions/aug.py


a = 244
b = 23

print(a)
a += 4
print(a)
a -= 2
print(a)
a <<= 4
print(a)
a >>= 2
print(a)
a |= 234324
print(a)
a &= 213213
print(a)
a ^= 2312
print(a)
a //= 324
print(a)
a += 1
print(a)
a /= 2
print(a)

print(b)
b **= 3
print(b)
-- [ruby] -----------
$ py2rb tests/functions/aug.py
a = 244
b = 23
print(a)
a += 4
print(a)
a -= 2
print(a)
a <<= 4
print(a)
a >>= 2
print(a)
a |= 234324
print(a)
a &= 213213
print(a)
a ^= 2312
print(a)
a /= 324
print(a)
a += 1
print(a)
a = a / 2.to_f
print(a)
print(b)
b = b ** 3
print(b)

-- [python] ---------
* tests/functions/bitand.py

x = 32424
y = 1437
z = x & y
print(z)
-- [ruby] -----------
$ py2rb tests/functions/bitand.py
x = 32424
y = 1437
z = x & y
print(z)

-- [python] ---------
* tests/functions/bitor.py

x = 123215
y = 3423
z = x | y
print(z)
-- [ruby] -----------
$ py2rb tests/functions/bitor.py
x = 123215
y = 3423
z = x | y
print(z)

-- [python] ---------
* tests/functions/bitxor.py
x = 32213
y = 98743
z = x ^ y
print(z)
-- [ruby] -----------
$ py2rb tests/functions/bitxor.py
x = 32213
y = 98743
z = x ^ y
print(z)

-- [python] ---------
* tests/functions/divfloor.py

x = 23423
y = 213
z = x // y

print(z)
-- [ruby] -----------
$ py2rb tests/functions/divfloor.py
x = 23423
y = 213
z = x / y
print(z)

-- [python] ---------
* tests/functions/float.py

a = '123.456'
b = float(a)
print(b)
-- [ruby] -----------
$ py2rb tests/functions/float.py
a = "123.456"
b = a.to_f
print(b)

-- [python] ---------
* tests/functions/floatdiv.py



a = 3
b = 2
c = a / b
print(c)
-- [ruby] -----------
$ py2rb tests/functions/floatdiv.py
a = 3
b = 2
c = a / b.to_f
print(c)

-- [python] ---------
* tests/functions/gtge.py

x = 123
y = 233
y2 = 233
z = 892

if x > y:
    print("x > y - incorrect")
else:
    print("not x > y - correct")

if y >= y2:
    print("y >= y2 - correct")
else:
    print("not y >= y2 - incorrect")

if z > x:
    print("z > x - correct")
else:
    print("not z > x - incorrect")

if y >= z:
    print("y >= z - incorrect")
else:
    print("not y >= x - correct")

-- [ruby] -----------
$ py2rb tests/functions/gtge.py
x = 123
y = 233
y2 = 233
z = 892
if x > y
  print("x > y - incorrect")
else
  print("not x > y - correct")
end
if y >= y2
  print("y >= y2 - correct")
else
  print("not y >= y2 - incorrect")
end
if z > x
  print("z > x - correct")
else
  print("not z > x - incorrect")
end
if y >= z
  print("y >= z - incorrect")
else
  print("not y >= x - correct")
end

-- [python] ---------
* tests/functions/in.py


a = { 1:'aaa', 'b':2 }

if 2 in a:
    print("2 in a - incorrect")

if 'b' in a:
    print("b in a - correct")

if 1 in a:
    print("1 in a - correct")

if 3 not in a:
    print("3 not in a - correct")

if 'x' not in a:
    print("x not in a - correct")
-- [ruby] -----------
$ py2rb tests/functions/in.py
a = {1 => "aaa", "b" => 2}
if a.include?(2)
  print("2 in a - incorrect")
end
if a.include?("b")
  print("b in a - correct")
end
if a.include?(1)
  print("1 in a - correct")
end
if !a.include?(3)
  print("3 not in a - correct")
end
if !a.include?("x")
  print("x not in a - correct")
end

-- [python] ---------
* tests/functions/int.py

x = '123'
y = int(x)
print(y)
-- [ruby] -----------
$ py2rb tests/functions/int.py
x = "123"
y = x.to_i
print(y)

-- [python] ---------
* tests/functions/isinstance.py

class Spam(object):

    def __init__(self,value):
        self.value = value

class Eggs(object):

    def __init__(self,value):
        self.value = value

s = Spam(1)
e = Eggs(2)

if isinstance(s,Spam):
    print("s is Spam - correct")

if isinstance(s,Eggs):
    print("s is Eggs - incorrect")

if isinstance(e,Spam):
    print("e is Spam - incorrect")

if isinstance(e,Eggs):
    print("e is Eggs - correct")

if isinstance(1, int):
    print("int - correct")

if isinstance(0.1, float):
    print("float - correct")

if isinstance('str', str):
    print("str - correct")

if isinstance([0], list):
    print("list - correct")

if isinstance((0, 1), tuple):
    print("tuple - correct")

if isinstance({'a': 1}, dict):
    print("dict - correct")
-- [ruby] -----------
$ py2rb tests/functions/isinstance.py
class Spam
  def initialize(value)
    @value = value
  end
end
class Eggs
  def initialize(value)
    @value = value
  end
end
s = Spam.new(1)
e = Eggs.new(2)
if is_bool(s.is_a? Spam)
  print("s is Spam - correct")
end
if is_bool(s.is_a? Eggs)
  print("s is Eggs - incorrect")
end
if is_bool(e.is_a? Spam)
  print("e is Spam - incorrect")
end
if is_bool(e.is_a? Eggs)
  print("e is Eggs - correct")
end
if is_bool(1.is_a? Integer)
  print("int - correct")
end
if is_bool(0.1.is_a? Float)
  print("float - correct")
end
if is_bool("str".is_a? String)
  print("str - correct")
end
if is_bool([0].is_a? Array)
  print("list - correct")
end
if is_bool([0, 1].is_a? Array)
  print("tuple - correct")
end
if is_bool({"a" => 1}.is_a? Hash)
  print("dict - correct")
end

-- [python] ---------
* tests/functions/len.py

mylist = [1,2,3]

print(len(mylist))
-- [ruby] -----------
$ py2rb tests/functions/len.py
mylist = [1, 2, 3]
print(mylist.size)

-- [python] ---------
* tests/functions/lshift.py

x = 10
y = x << 3
x <<= 3
print(x,y)
-- [ruby] -----------
$ py2rb tests/functions/lshift.py
x = 10
y = x << 3
x <<= 3
print(x, y)

-- [python] ---------
* tests/functions/ltle.py

x = 123
y = 233
y2 = 233
z = 892

if x < y:
    print("x < y - correct")
else:
    print("not x < y - incorrect")

if y <= y2:
    print("y <= y2 - correct")
else:
    print("not y <= y2 - incorrect")

if z < x:
    print("z < x - incorrect")
else:
    print("not z < x - correct")

if y <= z:
    print("y <= z - correct")
else:
    print("not y <= x - incorrect")

-- [ruby] -----------
$ py2rb tests/functions/ltle.py
x = 123
y = 233
y2 = 233
z = 892
if x < y
  print("x < y - correct")
else
  print("not x < y - incorrect")
end
if y <= y2
  print("y <= y2 - correct")
else
  print("not y <= y2 - incorrect")
end
if z < x
  print("z < x - incorrect")
else
  print("not z < x - correct")
end
if y <= z
  print("y <= z - correct")
else
  print("not y <= x - incorrect")
end

-- [python] ---------
* tests/functions/ne.py

#for x in [1,2]:
#    pass

for (x,y) in [(1,2),('aaa','bbb'),(4,4),('a','a')]:
    if x != y:
        print(str(x)+" <> "+str(y))
    else:
        print("not: " + str(x)+" <> "+str(y))


-- [ruby] -----------
$ py2rb tests/functions/ne.py
for (x, y) in [[1, 2], ["aaa", "bbb"], [4, 4], ["a", "a"]]
  if x != y
    print((x.to_s + " <> ") + y.to_s)
  else
    print((("not: " + x.to_s) + " <> ") + y.to_s)
  end
end

-- [python] ---------
* tests/functions/or.py

tests = [(False,False),(False,True),(True,False),(True,True),(True,None),(False,None),(None,True),(None,False)]

def pp(v):
    if v == False:
        return "F"
    if v == True:
        return "T"
    return "?"

for t in tests:
    (b1,b2) = t
    print(pp(b1) + " OR " + pp(b2) + "=" + pp(b1 or b2))
-- [ruby] -----------
$ py2rb tests/functions/or.py
tests = [[false, false], [false, true], [true, false], [true, true], [true, nil], [false, nil], [nil, true], [nil, false]]
def pp(v)
  if v == false
    return "F"
  end
  if v == true
    return "T"
  end
  return "?"
end
for t in tests
  b1,b2 = t
  print((((pp(b1) + " OR ") + pp(b2)) + "=") + pp(b1 || b2))
end

-- [python] ---------
* tests/functions/pop.py

a = [1,2,3,4]

print(a.pop())

-- [ruby] -----------
$ py2rb tests/functions/pop.py
a = [1, 2, 3, 4]
print(a.pop())

-- [python] ---------
* tests/functions/rshift.py

x = 345
y = x >> 7
x >>= 7
print(x,y)
-- [ruby] -----------
$ py2rb tests/functions/rshift.py
x = 345
y = x >> 7
x >>= 7
print(x, y)

-- [python] ---------
* tests/functions/sort.py

l = [3,2,1]

l.sort()

print(l[0])
print(l[1])
print(l[2])
-- [ruby] -----------
$ py2rb tests/functions/sort.py
l = [3, 2, 1]
l.sort!()
print(l[0])
print(l[1])
print(l[2])

-- [python] ---------
* tests/functions/str.py

a = 1
b = str(a)
c = 'x: ' + b
print(a)
print(b)
print(c)
-- [ruby] -----------
$ py2rb tests/functions/str.py
a = 1
b = a.to_s
c = "x: " + b
print(a)
print(b)
print(c)

-- [python] ---------
* tests/functions/ubitcomp.py

b = (~1 & 0xFFFF)
print(b)
-- [ruby] -----------
$ py2rb tests/functions/ubitcomp.py
b = ~1 & 65535
print(b)

-- [python] ---------
* tests/functions/uminus.py

x = -7623
print(x)
-- [ruby] -----------
$ py2rb tests/functions/uminus.py
x = -7623
print(x)

-- [python] ---------
* tests/functions/uplus.py

x = +7623
print(x)
-- [ruby] -----------
$ py2rb tests/functions/uplus.py
x = +7623
print(x)

-- [python] ---------
* tests/lists/all.py

l = [4,7,3,4,2,1]
v = all(l)
print(str(v).upper())

print(str(all([])).upper())
print(str(all({})).upper())
print(str(all(())).upper())
print(str(all([False])).upper())
print(str(all([None])).upper())
print(str(all([0])).upper())
print(str(all([''])).upper())
print(str(all([[]])).upper())
print(str(all([{}])).upper())

l = [0,{}]
v = all(l)
print(str(v).upper())
-- [ruby] -----------
$ py2rb tests/lists/all.py
l = [4, 7, 3, 4, 2, 1]
v = l.is_all?
print(v.to_s.upcase())
print([].is_all?.to_s.upcase())
print({}.is_all?.to_s.upcase())
print([].is_all?.to_s.upcase())
print([false].is_all?.to_s.upcase())
print([nil].is_all?.to_s.upcase())
print([0].is_all?.to_s.upcase())
print([""].is_all?.to_s.upcase())
print([[]].is_all?.to_s.upcase())
print([{}].is_all?.to_s.upcase())
l = [0, {}]
v = l.is_all?
print(v.to_s.upcase())

-- [python] ---------
* tests/lists/any.py

l = [4,7,3,4,2,1]
v = any(l)
print(str(v).upper())

print(str(any([])).upper())
print(str(any({})).upper())
print(str(any(())).upper())
print(str(any([False])).upper())
print(str(any([None])).upper())
print(str(any([0])).upper())
print(str(any([''])).upper())
print(str(any([[]])).upper())
print(str(any([{}])).upper())

l = [0,{}]
v = any(l)
print(str(v).upper())
-- [ruby] -----------
$ py2rb tests/lists/any.py
l = [4, 7, 3, 4, 2, 1]
v = l.is_any?
print(v.to_s.upcase())
print([].is_any?.to_s.upcase())
print({}.is_any?.to_s.upcase())
print([].is_any?.to_s.upcase())
print([false].is_any?.to_s.upcase())
print([nil].is_any?.to_s.upcase())
print([0].is_any?.to_s.upcase())
print([""].is_any?.to_s.upcase())
print([[]].is_any?.to_s.upcase())
print([{}].is_any?.to_s.upcase())
l = [0, {}]
v = l.is_any?
print(v.to_s.upcase())

-- [python] ---------
* tests/lists/extend.py

list1 = [1,2,'f',44]
list2 = ['a',99,77]

list3 = list1[:]
list3.extend(list2)

for item in list3:
    print(item)
-- [ruby] -----------
$ py2rb tests/lists/extend.py
list1 = [1, 2, "f", 44]
list2 = ["a", 99, 77]
list3 = list1[0..-1]
list3.concat(list2)
for item in list3
  print(item)
end

-- [python] ---------
* tests/lists/filter.py

l = [1,2,3,4,5,6,7,8,8]

l2 = [x for x in l if x>4]

for v in l2:
    print(v)


-- [ruby] -----------
$ py2rb tests/lists/filter.py
l = [1, 2, 3, 4, 5, 6, 7, 8, 8]
l2 = l.select{|x| x > 4}.map{|x| x}
for v in l2
  print(v)
end

-- [python] ---------
* tests/lists/in.py


l = ['a','b','c']

def intest(item,ll):
    if item in ll:
        print(str(item) + ' is in list')
    else:
        print(str(item) + ' is not in list')


intest('a',l)
intest('b',l)
intest(99,l)
intest(0,l)
intest('z',l)
intest('c',l)


-- [ruby] -----------
$ py2rb tests/lists/in.py
l = ["a", "b", "c"]
def intest(item, ll)
  if ll.include?(item)
    print(item.to_s + " is in list")
  else
    print(item.to_s + " is not in list")
  end
end
intest("a", l)
intest("b", l)
intest(99, l)
intest(0, l)
intest("z", l)
intest("c", l)

-- [python] ---------
* tests/lists/insert.py
a = []
a.insert(0, 1)
print(a)
a.insert(0, 2)
print(a)
a.insert(0, 3)
print(a)
a.insert(1, 4)
print(a)
a.insert(2, 5)
print(a)
a.insert(5, 6)
print(a)
-- [ruby] -----------
$ py2rb tests/lists/insert.py
a = []
a.insert(0, 1)
print(a)
a.insert(0, 2)
print(a)
a.insert(0, 3)
print(a)
a.insert(1, 4)
print(a)
a.insert(2, 5)
print(a)
a.insert(5, 6)
print(a)

-- [python] ---------
* tests/lists/map.py

def foo(x):
    return x*x

y = [1,2,3,4,5]

z = list(map(foo,y))
for val in z:
    print(val)
-- [ruby] -----------
$ py2rb tests/lists/map.py
def foo(x)
  return x * x
end
y = [1, 2, 3, 4, 5]
z = y.map{|_| foo(_)}.to_a
for val in z
  print(val)
end

-- [python] ---------
* tests/lists/max.py

l = [4,7,3,4,2,1]

v = max(l)

print(v)
-- [ruby] -----------
$ py2rb tests/lists/max.py
l = [4, 7, 3, 4, 2, 1]
v = l.max
print(v)

-- [python] ---------
* tests/lists/min.py

l = [4,7,3,4,2,1]

v = min(l)

print(v)
-- [ruby] -----------
$ py2rb tests/lists/min.py
l = [4, 7, 3, 4, 2, 1]
v = l.min
print(v)

-- [python] ---------
* tests/lists/reverse.py
a = [1, 2, 3, 4]
a.reverse()
print(a)
-- [ruby] -----------
$ py2rb tests/lists/reverse.py
a = [1, 2, 3, 4]
a.reverse!()
print(a)

-- [python] ---------
* tests/lists/subclass.py
class A(list):

    def my_append(self, a):
        self.append(a)

a = A()
print(a)
a.append(5)
print(a)
a.append(6)
print(a)
a.remove(5)
print(a)
-- [ruby] -----------
$ py2rb tests/lists/subclass.py
class A < Array
  def my_append(a)
    @append.(a)
  end
end
a = A.new()
print(a)
a.push(5)
print(a)
a.push(6)
print(a)
a.remove(5)
print(a)

-- [python] ---------
* tests/lists/subclass2.py
class List(object):

    def __init__(self, l=[]):
        self._list = list(l)

    def append(self, x):
        self._list.append(x)

    def remove(self, x):
        self._list.remove(x)

    def __str__(self):
        return str(self._list)

class A(List):

    def my_append(self, a):
        self.append(a)

a = A()
print(a)
a.append(5)
print(a)
a.append(6)
print(a)
a.remove(5)
print(a)
-- [ruby] -----------
$ py2rb tests/lists/subclass2.py
class List
  def initialize(l: [])
    @_list = l.to_a
  end
  def append(x)
    @_list.push(x)
  end
  def remove(x)
    @_list.remove(x)
  end
  def to_s()
    return @_list.to_s
  end
  alias :push :append
end
class A < List
  def my_append(a)
    append(a)
  end
end
a = A.new()
print(a)
a.push(5)
print(a)
a.push(6)
print(a)
a.remove(5)
print(a)

-- [python] ---------
* tests/lists/subclass3.py
class List(object):

    def __init__(self, l=[]):
        self._list = list(l)

    def append(self, x):
        self._list.append(x)

    def remove(self, x):
        self._list.remove(x)

    def __str__(self):
        return str(self._list)

class Layer(List):
    pass

l1 = Layer()
l1.append(1)
l1.append(2)
l2 = list()
l2.append(3)
l2.append(4)
print(l1)
print(l2)
-- [ruby] -----------
$ py2rb tests/lists/subclass3.py
class List
  def initialize(l: [])
    @_list = l.to_a
  end
  def append(x)
    @_list.push(x)
  end
  def remove(x)
    @_list.remove(x)
  end
  def to_s()
    return @_list.to_s
  end
  alias :push :append
end
class Layer < List
  # pass
end
l1 = Layer.new()
l1.push(1)
l1.push(2)
l2 = []
l2.push(3)
l2.push(4)
print(l1)
print(l2)

-- [python] ---------
* tests/lists/sum.py

s = [1,2,3,4,5]
t = sum(s)
u = sum([x*x for x in s])
print(t,u)
-- [ruby] -----------
$ py2rb tests/lists/sum.py
s = [1, 2, 3, 4, 5]
t = s.sum
u = (s.map{|x| x * x}).sum
print(t, u)

-- [python] ---------
* tests/lists/sum2.py
s = [1,2,3,4,5]
print(sum(s))

print(sum([1, 8, 11]))

print(sum((1, 8, 11)))
-- [ruby] -----------
$ py2rb tests/lists/sum2.py
s = [1, 2, 3, 4, 5]
print(s.sum)
print([1, 8, 11].sum)
print([1, 8, 11].sum)

-- [python] ---------
* tests/lists/xrange.py

xr = range(20,40)

for x in xr:
    print(x)
-- [ruby] -----------
$ py2rb tests/lists/xrange.py
xr = 20.upto(40-1)
for x in xr
  print(x)
end

-- [python] ---------
* tests/lists/zip.py


l1 = [1,2,3,4,5]
l2 = [5,4,3,2,1]
l3 = [4,4,4,4]

l4 = list(zip(l1,l2,l3))

for item in l4:
    print("---")
    for val in item:
        print(val)
-- [ruby] -----------
$ py2rb tests/lists/zip.py
l1 = [1, 2, 3, 4, 5]
l2 = [5, 4, 3, 2, 1]
l3 = [4, 4, 4, 4]
l4 = zip_p(l1, l2, l3).to_a
for item in l4
  print("---")
  for val in item
    print(val)
  end
end

-- [python] ---------
* tests/modules/classname.py

from modules.moda import ModA

m = ModA('hello')
m.describe()

mc = m.clone()
mc.describe()
-- [ruby] -----------
$ py2rb tests/modules/classname.py
require_relative 'modules/moda'
include Modules::Moda
m = ModA.new("hello")
m.describe()
mc = m.clone()
mc.describe()

-- [python] ---------
* tests/modules/from_import.py

from imported.modulea import modulea_fn
from imported.moduleb import moduleb_fn as modb_fn
from imported.modulec import *
from imported.modulee import *

modulea_fn()
modb_fn()
foo()
bar()
-- [ruby] -----------
$ py2rb tests/modules/from_import.py
require_relative 'imported/modulea'
include Imported::Modulea
require_relative 'imported/moduleb'
include Imported::Moduleb
alias modb_fn moduleb_fn
require_relative 'imported/modulec'
include Imported::Modulec
require_relative 'imported/modulee'
include Imported::Modulee
modulea_fn()
modb_fn()
foo()
bar()

-- [python] ---------
* tests/modules/from_import_as_module.py

from imported.modulea import *
from imported import moduleb as foo

modulea_fn()
foo.moduleb_fn()

ma = modulea_class()
print(ma.msg(1))

mb = foo.moduleb_class()
print(mb.msg(2))
-- [ruby] -----------
$ py2rb tests/modules/from_import_as_module.py
require_relative 'imported/modulea'
include Imported::Modulea
require_relative 'imported/moduleb'
include Imported
Foo = Moduleb
modulea_fn()
Foo::moduleb_fn()
ma = Modulea_class.new()
print(ma.msg(1))
mb = Foo::Moduleb_class.new()
print(mb.msg(2))

-- [python] ---------
* tests/modules/import.py

from imported.modulea import *
import imported.moduleb

modulea_fn()
imported.moduleb.moduleb_fn()

ma = modulea_class()
print(ma.msg(1))

mb = imported.moduleb.moduleb_class()
print(mb.msg(2))
-- [ruby] -----------
$ py2rb tests/modules/import.py
require_relative 'imported/modulea'
include Imported::Modulea
require_relative 'imported/moduleb'
modulea_fn()
Imported::Moduleb::moduleb_fn()
ma = Modulea_class.new()
print(ma.msg(1))
mb = Imported::Moduleb::Moduleb_class.new()
print(mb.msg(2))

-- [python] ---------
* tests/modules/import_alias.py

from imported.alias_fns import foo as bar
from imported.alias_classes import spam as eggs

# call imported function
bar()

# call imported class
e = eggs()
e.msg()


-- [ruby] -----------
$ py2rb tests/modules/import_alias.py
require_relative 'imported/alias_fns'
include Imported::Alias_fns
alias bar foo
require_relative 'imported/alias_classes'
include Imported::Alias_classes
Eggs = Spam
bar()
e = Eggs.new()
e.msg()

-- [python] ---------
* tests/modules/import_as_module.py

from imported.modulea import *
import imported.moduleb as foo

modulea_fn()
foo.moduleb_fn()

ma = modulea_class()
print(ma.msg(1))

mb = foo.moduleb_class()
print(mb.msg(2))
-- [ruby] -----------
$ py2rb tests/modules/import_as_module.py
require_relative 'imported/modulea'
include Imported::Modulea
require_relative 'imported/moduleb'
Foo = Imported::Moduleb
modulea_fn()
Foo::moduleb_fn()
ma = Modulea_class.new()
print(ma.msg(1))
mb = Foo::Moduleb_class.new()
print(mb.msg(2))

-- [python] ---------
* tests/modules/import_class.py


import modules.klasses

k = modules.klasses.Klass()

k.sayhello()
modules.klasses.Klass.sayhello()

-- [ruby] -----------
$ py2rb tests/modules/import_class.py
require_relative 'modules/klasses'
k = Modules::Klasses::Klass.new()
k.sayhello()
Modules::Klasses::Klass.sayhello()

-- [python] ---------
* tests/modules/import_global.py

import imported.moduleb
import imported.moduled

imported.moduleb.moduleb_fn()
imported.moduled.moduled_fn()
-- [ruby] -----------
$ py2rb tests/modules/import_global.py
require_relative 'imported/moduleb'
require_relative 'imported/moduled'
Imported::Moduleb::moduleb_fn()
Imported::Moduled::moduled_fn()

-- [python] ---------
* tests/modules/import_init.py
import children
children.fuga.hi()
children.hoge.hi()
b = children.bar.bar_class()
b.hi()
children.grandchildren.foo.hi()

-- [ruby] -----------
$ py2rb tests/modules/import_init.py
require_relative 'children/__init__'
require_relative 'children/grandchildren/foo'
require_relative 'children/hoge'
require_relative 'children/fuga'
require_relative 'children/bar'
Children::Fuga::hi()
Children::Hoge::hi()
b = Children::Bar::Bar_class.new()
b.hi()
Children::Grandchildren::Foo::hi()

-- [python] ---------
* tests/modules/import_multi.py

import imported.modulec

def foo():
    print("foo")
    imported.modulec.foo()

foo()
-- [ruby] -----------
$ py2rb tests/modules/import_multi.py
require_relative 'imported/modulec'
def foo()
  print("foo")
  Imported::Modulec::foo()
end
foo()

-- [python] ---------
* tests/numpy/abs.py
# coding: utf-8
import numpy as np

def print_matrix(data):
    data_i = []
    for i in list(data):
        data_j = []
        for j in i:
            data_j.append(j)
        data_i.append(data_j)
    print(data_i)

def print_array(data):
    datas = []
    for i in data:
        datas.append(i)
    print(datas)


"""
1-dim
"""
x = np.array([2,-3,4])
print_array(x)

y = np.abs(x)
print_array(y)

y = np.absolute(x)
print_array(y)
"""
2-dim
"""
z = np.array([[-2,3,-6],[3,-4,5]])
print_matrix(z)

y = np.abs(z)
print_matrix(y)

-- [ruby] -----------
$ py2rb tests/numpy/abs.py
require 'numo/narray'
def print_matrix(data)
  data_i = []
  for i in data.to_a
    data_j = []
    for j in i
      data_j.push(j)
    end
    data_i.push(data_j)
  end
  print(data_i)
end
def print_array(data)
  datas = []
  for i in data
    datas.push(i)
  end
  print(datas)
end
# 
# 1-dim
# 
x = Numo::NArray.cast([2, -3, 4])
print_array(x)
y = Numo::NArray.cast(x).abs()
print_array(y)
y = Numo::NArray.cast(x).abs()
print_array(y)
# 
# 2-dim
# 
z = Numo::NArray.cast([[-2, 3, -6], [3, -4, 5]])
print_matrix(z)
y = Numo::NArray.cast(z).abs()
print_matrix(y)

-- [python] ---------
* tests/numpy/all.py
# coding: utf-8
import numpy as np

v = np.all([[True, False], [True, True]])
print(str(v).upper())

""" [True, False] => [1, 0] """
v = np.all([[True, False], [True, True]], axis=0)
for a in v:
    if a in (True, 1):
        print('TRUE')
    else:
        print('FALSE')

v = np.all([-1, 0, 4])
print(str(v).upper())

v = np.all([1.0 ,np.nan])
print(str(v).upper())

-- [ruby] -----------
$ py2rb tests/numpy/all.py
require 'numo/narray'
v = Numo::Bit.cast([[true, false], [true, true]]).all?()
print(v.to_s.upcase())
#  [True, False] => [1, 0] 
v = Numo::Bit.cast([[true, false], [true, true]]).all?(axis: 0)
for a in v
  if [true, 1].include?(a)
    print("TRUE")
  else
    print("FALSE")
  end
end
v = Numo::Bit.cast([-1, 0, 4]).all?()
print(v.to_s.upcase())
v = Numo::Bit.cast([1.0, Float::NAN]).all?()
print(v.to_s.upcase())

-- [python] ---------
* tests/numpy/any.py
# coding: utf-8
import numpy as np

v = np.any([[True, False], [True, True]])
print(str(v).upper())

""" [False, True] => [0, 1] """
v = np.any([[True, False], [True, True]], axis=0)
for a in v:
    if a in (True, 1):
        print('TRUE')
    else:
        print('FALSE')

v = np.any([-1, 0, 4])
print(str(v).upper())

v = np.any(np.nan)
print(str(v).upper())

-- [ruby] -----------
$ py2rb tests/numpy/any.py
require 'numo/narray'
v = Numo::Bit.cast([[true, false], [true, true]]).any?()
print(v.to_s.upcase())
#  [False, True] => [0, 1] 
v = Numo::Bit.cast([[true, false], [true, true]]).any?(axis: 0)
for a in v
  if [true, 1].include?(a)
    print("TRUE")
  else
    print("FALSE")
  end
end
v = Numo::Bit.cast([-1, 0, 4]).any?()
print(v.to_s.upcase())
v = Numo::Bit.cast(Float::NAN).any?()
print(v.to_s.upcase())

-- [python] ---------
* tests/numpy/arange.py
import numpy as np

def print_array(data):
    datas = []
    for i in data:
        if float("%.3f" % abs(i)) == 0:
            datas.append(float("%.3f" % abs(i)))
        else:
            datas.append(float("%.3f" % i))
    print(datas)

x = np.arange(-1.0, 1.0, 0.1)
print_array(x)
x = np.arange(6)
print_array(x)
x = np.arange(1,6) 
print_array(x)
x = np.arange(1,6,2)
print_array(x)

-- [ruby] -----------
$ py2rb tests/numpy/arange.py
require 'numo/narray'
def print_array(data)
  datas = []
  for i in data
    if ("%.3f" % i.abs).to_f == 0
      datas.push(("%.3f" % i.abs).to_f)
    else
      datas.push(("%.3f" % i).to_f)
    end
  end
  print(datas)
end
x = Numo::DFloat.new(((1.0-(-1.0))/(0.1).to_f).ceil).seq(-1.0, 0.1)
print_array(x)
x = Numo::DFloat.new(6).seq(0)
print_array(x)
x = Numo::DFloat.new(6-(1)).seq(1)
print_array(x)
x = Numo::DFloat.new(((6-(1))/(2).to_f).ceil).seq(1, 2)
print_array(x)

-- [python] ---------
* tests/numpy/array2string.py
import numpy as np

x = np.array([1,2,3,4,5,6,7,8,9,10], dtype='int8')
print(list(x))
print(np.array2string(x))
print(np.array2string(x, None))
print(np.array2string(x, None, None, None, ' '))
print(np.array2string(x, precision=2, separator=',', suppress_small=True))
print(np.array2string(x, precision=3, separator=',', suppress_small=True))
print('hoge : ' +np.array2string(x, precision=4, separator=',', suppress_small=True, prefix='hoge : '))
print(np.array2string(x, precision=4))
print(np.array2string(x))
-- [ruby] -----------
$ py2rb tests/numpy/array2string.py
require 'numo/narray'
x = Numo::NArray.cast([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(x.to_a)
print((x).format_to_a.join())
print((x).format_to_a.join())
print((x).format_to_a.join(" "))
print((x).format_to_a.join(","))
print((x).format_to_a.join(","))
print("hoge : " + (x).format_to_a.join(","))
print((x).format_to_a.join())
print((x).format_to_a.join())

-- [python] ---------
* tests/numpy/asarray.py
import numpy as np

def print_matrix(data):
    data_i = []
    for i in list(data):
        data_j = []
        for j in i:
            data_j.append(int("%d" % j))
        data_i.append(data_j)
    print(data_i)

def print_array(data):
    datas = []
    for i in data:
        datas.append(float("%.3f" % i))
    print(datas)

x = np.asarray([[1.,2.],[3.,4.]])
print_matrix(x)

x = np.asarray([1.,2.])
print_array(x)

y = np.asarray([3.,4.])
print_array(y)

z = (x + y)[0]
print(z)
-- [ruby] -----------
$ py2rb tests/numpy/asarray.py
require 'numo/narray'
def print_matrix(data)
  data_i = []
  for i in data.to_a
    data_j = []
    for j in i
      data_j.push(("%d" % j).to_i)
    end
    data_i.push(data_j)
  end
  print(data_i)
end
def print_array(data)
  datas = []
  for i in data
    datas.push(("%.3f" % i).to_f)
  end
  print(datas)
end
x = Numo::NArray.cast([[1.0, 2.0], [3.0, 4.0]])
print_matrix(x)
x = Numo::NArray.cast([1.0, 2.0])
print_array(x)
y = Numo::NArray.cast([3.0, 4.0])
print_array(y)
z = (x + y)[0]
print(z)

-- [python] ---------
* tests/numpy/ellipsis.py
import numpy as np

x = np.array([1, 1, 1])
x[...] = 1
-- [ruby] -----------
$ py2rb tests/numpy/ellipsis.py
require 'numo/narray'
x = Numo::NArray.cast([1, 1, 1])
x[false] = 1

-- [python] ---------
* tests/numpy/empty.py
# coding: utf-8
import numpy as np

def print_array(data):
    datas = []
    for i in data:
        datas.append(i)
    print(datas)

x = np.empty(())
print_array(x.shape)

x = np.empty((0))
print_array(x.shape)

x = np.empty((0,0))
print_array(x.shape)

x = np.empty(3, dtype=np.float32)
print_array(x.shape)

x = np.empty((2,3))
print_array(x.shape)

-- [ruby] -----------
$ py2rb tests/numpy/empty.py
require 'numo/narray'
def print_array(data)
  datas = []
  for i in data
    datas.push(i)
  end
  print(datas)
end
x = Numo::DFloat.new([])
print_array(x.shape)
x = Numo::DFloat.new(0)
print_array(x.shape)
x = Numo::DFloat.new([0, 0])
print_array(x.shape)
x = Numo::SFloat.new(3)
print_array(x.shape)
x = Numo::DFloat.new([2, 3])
print_array(x.shape)

-- [python] ---------
* tests/numpy/ext_slice.py
import numpy as np

def print_matrix(data):
    data_i = []
    for i in list(data):
        data_j = []
        for j in i:
            data_j.append(int("%d" % j))
        data_i.append(data_j)
    print(data_i)

def print_array(data):
    datas = []
    for i in data:
        datas.append(int("%d" % i))
    print(datas)

x = np.asarray([[1,2,3],[4,5,6]])
print_matrix(x)

"""
x[0,:]
"""
print_array(x[0,:])

"""
x[1,1:]
"""
y = x[1,1:]
print_array(y)

"""
x[1,:2]
"""
x[1,:2] = 5
print_array(y)
print_matrix(x)

x = np.asarray([[1,2,3],[4,5,6]])
print_matrix(x)

"""
x[:,0]
"""
print_array(x[:,0])

"""
x[:,1]
"""
print_array(x[:,1])

x = np.asarray([[[1,2,3],[4,5,6]],[[11,12,13],[14,15,16]]])
#print_matrix(x)

"""
x[0,:] Not Support

It is not supportable if the number of arguments and the number of dimensions are different.

print_matrix(x[0,:])
"""

"""
x[0,1,:]
"""
print_array(x[0,1,:])
-- [ruby] -----------
$ py2rb tests/numpy/ext_slice.py
require 'numo/narray'
def print_matrix(data)
  data_i = []
  for i in data.to_a
    data_j = []
    for j in i
      data_j.push(("%d" % j).to_i)
    end
    data_i.push(data_j)
  end
  print(data_i)
end
def print_array(data)
  datas = []
  for i in data
    datas.push(("%d" % i).to_i)
  end
  print(datas)
end
x = Numo::NArray.cast([[1, 2, 3], [4, 5, 6]])
print_matrix(x)
# 
# x[0,:]
# 
print_array(x[0, 0..-1])
# 
# x[1,1:]
# 
y = x[1, 1..-1]
print_array(y)
# 
# x[1,:2]
# 
x[1, 0...2] = 5
print_array(y)
print_matrix(x)
x = Numo::NArray.cast([[1, 2, 3], [4, 5, 6]])
print_matrix(x)
# 
# x[:,0]
# 
print_array(x[0..-1, 0])
# 
# x[:,1]
# 
print_array(x[0..-1, 1])
x = Numo::NArray.cast([[[1, 2, 3], [4, 5, 6]], [[11, 12, 13], [14, 15, 16]]])
# 
# x[0,:] Not Support
# 
# It is not supportable if the number of arguments and the number of dimensions are different.
# 
# print_matrix(x[0,:])
# 
# 
# x[0,1,:]
# 
print_array(x[0, 1, 0..-1])

-- [python] ---------
* tests/numpy/full.py
# coding: utf-8
import numpy as np

def print_matrix(data):
    data_i = []
    for i in list(data):
        data_j = []
        for j in i:
            data_j.append(int("%d" % j))
        data_i.append(data_j)
    print(data_i)

x = np.full((2, 2), 5, dtype=np.int64)
print_matrix(x)

-- [ruby] -----------
$ py2rb tests/numpy/full.py
require 'numo/narray'
def print_matrix(data)
  data_i = []
  for i in data.to_a
    data_j = []
    for j in i
      data_j.push(("%d" % j).to_i)
    end
    data_i.push(data_j)
  end
  print(data_i)
end
x = Numo::Int64.new([2, 2]).fill(5)
print_matrix(x)

-- [python] ---------
* tests/numpy/insert.py
import numpy as np

def print_array(data):
    datas = []
    for i in data:
        datas.append(i)
    print(datas)
def print_matrix(data):
    data_i = []
    for i in list(data):
        data_j = []
        for j in i:
            data_j.append(j)
        data_i.append(data_j)
    print(data_i)

x = np.array([[1, 1], [2, 2], [3, 3]], dtype=np.int8)
"""[[1, 1], [2, 2], [3, 3]] => [1, 5, 1, 2, 2, 3, 3]"""
x = np.insert(x, 1, 5)
print_array(x)

x = np.array([[1, 1], [2, 2], [3, 3]])
"""[[1, 1], [2, 2], [3, 3]] => [[1, 5, 1], [2, 5, 2], [3, 5, 3]]"""
x = np.insert(x, 1, 5, axis=1)
print_matrix(x)
-- [ruby] -----------
$ py2rb tests/numpy/insert.py
require 'numo/narray'
def print_array(data)
  datas = []
  for i in data
    datas.push(i)
  end
  print(datas)
end
def print_matrix(data)
  data_i = []
  for i in data.to_a
    data_j = []
    for j in i
      data_j.push(j)
    end
    data_i.push(data_j)
  end
  print(data_i)
end
x = Numo::Int8.cast([[1, 1], [2, 2], [3, 3]])
# [[1, 1], [2, 2], [3, 3]] => [1, 5, 1, 2, 2, 3, 3]
x = (x).insert(1, 5)
print_array(x)
x = Numo::NArray.cast([[1, 1], [2, 2], [3, 3]])
# [[1, 1], [2, 2], [3, 3]] => [[1, 5, 1], [2, 5, 2], [3, 5, 3]]
x = (x).insert(1, 5, axis: 1)
print_matrix(x)

-- [python] ---------
* tests/numpy/like.py
# coding: utf-8
import numpy as np

def print_matrix(data):
    data_i = []
    for i in list(data):
        data_j = []
        for j in i:
            data_j.append(int("%d" % j))
        data_i.append(data_j)
    print(data_i)

x = np.arange(6)
x = x.reshape(2, 3)
print_matrix(x)

x = np.ones_like(x)
print_matrix(x)

x = np.zeros_like(x)
print_matrix(x)

x = np.full_like(x, 1)
print_matrix(x)

a = ([1,2,3], [4,5,6])   
x = np.empty_like(a)
print(list(x.shape))

a = np.array([[1., 2., 3.],[4.,5.,6.]])
x = np.empty_like(a)
print(list(x.shape))
-- [ruby] -----------
$ py2rb tests/numpy/like.py
require 'numo/narray'
def print_matrix(data)
  data_i = []
  for i in data.to_a
    data_j = []
    for j in i
      data_j.push(("%d" % j).to_i)
    end
    data_i.push(data_j)
  end
  print(data_i)
end
x = Numo::DFloat.new(6).seq(0)
x = x.reshape(2, 3)
print_matrix(x)
x = (x).new_ones()
print_matrix(x)
x = (x).new_zeros()
print_matrix(x)
x = (x).new_fill(1)
print_matrix(x)
a = [[1, 2, 3], [4, 5, 6]]
x = Numo::NArray.new_like(a)
print(x.shape.to_a)
a = Numo::NArray.cast([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
x = Numo::NArray.new_like(a)
print(x.shape.to_a)

-- [python] ---------
* tests/numpy/linspace.py
import numpy as np

x = np.linspace(2.0, 3.0, num=5)
for a in x:
    print(a)

-- [ruby] -----------
$ py2rb tests/numpy/linspace.py
require 'numo/narray'
x = Numo::DFloat.linspace(2.0, 3.0, 5)
for a in x
  print(a)
end

-- [python] ---------
* tests/numpy/max_min.py
# coding: utf-8
import numpy as np

def print_matrix(data):
    data_i = []
    for i in list(data):
        data_j = []
        for j in i:
            data_j.append(j)
        data_i.append(data_j)
    print(data_i)

def print_array(data):
    datas = []
    for i in data:
        datas.append(i)
    print(datas)


x = np.array([2,3,4])
print_array(x)

z = np.array([[2,3,6],[3,4,5]])
print_matrix(z)

"""
max
"""
y = x.max()
print(y)
y = np.max([2, 3, 4])
print(y)

"""
amax
"""
y = np.amax([2, 3, 4])
print(y)

"""
max axis=0
"""
y = z.max(axis=0)
print_array(y)

"""
max axis=1
"""
y = np.max([[2,3,6],[3,4,5]], axis=1)
print_array(y)

"""
min
"""
y = x.min()
print(y)
y = np.min([2, 3, 4])
print(y)

"""
amin
"""
y = np.amin([2, 3, 4])
print(y)

"""
min axis=0
"""
y = z.min(axis=0)
print_array(y)

"""
min axis=1
"""
y = np.min([[2,3,6],[3,4,5]], axis=1)
print_array(y)

"""
max axis=0 keepdims
"""
y = np.max([[2,3,6],[3,4,5]], axis=0, keepdims=True)
print_matrix(y)

"""
min keepdims
"""
y = np.min([[2,3,6],[3,4,5]], keepdims=True)
print_matrix(y)
-- [ruby] -----------
$ py2rb tests/numpy/max_min.py
require 'numo/narray'
def print_matrix(data)
  data_i = []
  for i in data.to_a
    data_j = []
    for j in i
      data_j.push(j)
    end
    data_i.push(data_j)
  end
  print(data_i)
end
def print_array(data)
  datas = []
  for i in data
    datas.push(i)
  end
  print(datas)
end
x = Numo::NArray.cast([2, 3, 4])
print_array(x)
z = Numo::NArray.cast([[2, 3, 6], [3, 4, 5]])
print_matrix(z)
# 
# max
# 
y = x.max()
print(y)
y = Numo::NArray.cast([2, 3, 4]).max()
print(y)
# 
# amax
# 
y = Numo::NArray.cast([2, 3, 4]).max()
print(y)
# 
# max axis=0
# 
y = z.max(axis: 0)
print_array(y)
# 
# max axis=1
# 
y = Numo::NArray.cast([[2, 3, 6], [3, 4, 5]]).max(axis: 1)
print_array(y)
# 
# min
# 
y = x.min()
print(y)
y = Numo::NArray.cast([2, 3, 4]).min()
print(y)
# 
# amin
# 
y = Numo::NArray.cast([2, 3, 4]).min()
print(y)
# 
# min axis=0
# 
y = z.min(axis: 0)
print_array(y)
# 
# min axis=1
# 
y = Numo::NArray.cast([[2, 3, 6], [3, 4, 5]]).min(axis: 1)
print_array(y)
# 
# max axis=0 keepdims
# 
y = Numo::NArray.cast([[2, 3, 6], [3, 4, 5]]).max(axis: 0, keepdims: true)
print_matrix(y)
# 
# min keepdims
# 
y = Numo::NArray.cast([[2, 3, 6], [3, 4, 5]]).min(keepdims: true)
print_matrix(y)

-- [python] ---------
* tests/numpy/maximum_minimum.py
# coding: utf-8
import numpy as np

def print_array(data):
    datas = []
    for i in data:
        if float("%.3f" % abs(i)) == 0:
            datas.append(float("%.3f" % abs(i)))
        else:
            datas.append(float("%.3f" % i))
    print(datas)

x = np.arange(-5.0, 5.0, 0.1)
print(len(x))
print_array(list(x))

"""
maximum
"""
y = np.maximum(0, x)
print(len(y))
print_array(list(y))

"""
minimum
"""
y = np.minimum(0, x)
print(len(y))
print_array(list(y))
-- [ruby] -----------
$ py2rb tests/numpy/maximum_minimum.py
require 'numo/narray'
def print_array(data)
  datas = []
  for i in data
    if ("%.3f" % i.abs).to_f == 0
      datas.push(("%.3f" % i.abs).to_f)
    else
      datas.push(("%.3f" % i).to_f)
    end
  end
  print(datas)
end
x = Numo::DFloat.new(((5.0-(-5.0))/(0.1).to_f).ceil).seq(-5.0, 0.1)
print(x.size)
print_array(x.to_a)
# 
# maximum
# 
y = Numo::DFloat.maximum(0, x)
print(y.size)
print_array(y.to_a)
# 
# minimum
# 
y = Numo::DFloat.minimum(0, x)
print(y.size)
print_array(y.to_a)

-- [python] ---------
* tests/numpy/ndarray.py
import numpy as np

a = np.array([1,2,3,4,5], dtype='int8')
if isinstance(a, np.ndarray):
    print('OK')
else:
    print('NG')

-- [ruby] -----------
$ py2rb tests/numpy/ndarray.py
require 'numo/narray'
a = Numo::NArray.cast([1, 2, 3, 4, 5])
if is_bool(a.is_a? Numo::NArray)
  print("OK")
else
  print("NG")
end

-- [python] ---------
* tests/numpy/ndarray2.py
import numpy
from numpy import ndarray

a = numpy.array([1,2,3,4,5], dtype='int8')
if isinstance(a, ndarray):
    print('OK')
else:
    print('NG')

-- [ruby] -----------
$ py2rb tests/numpy/ndarray2.py
require 'numo/narray'
include Numo
a = Numo::NArray.cast([1, 2, 3, 4, 5])
if is_bool(a.is_a? NArray)
  print("OK")
else
  print("NG")
end

-- [python] ---------
* tests/numpy/ndarray3.py
from numpy import *

a = array([1,2,3,4,5], dtype='int8')
if isinstance(a, ndarray):
    print('OK')
else:
    print('NG')

-- [ruby] -----------
$ py2rb tests/numpy/ndarray3.py
require 'numo/narray'
include Numo
a = NArray.cast([1, 2, 3, 4, 5])
if is_bool(a.is_a? NArray)
  print("OK")
else
  print("NG")
end

-- [python] ---------
* tests/numpy/not_like.py
# coding: utf-8
import numpy as np

def print_matrix(data):
    data_i = []
    for i in list(data):
        data_j = []
        for j in i:
            data_j.append(int("%d" % j))
        data_i.append(data_j)
    print(data_i)

def print_array(data):
    datas = []
    for i in data:
        if float("%.3f" % abs(i)) == 0:
            datas.append(float("%.3f" % abs(i)))
        else:
            datas.append(float("%.3f" % i))
    print(datas)

x = np.ones(5)
print_array(x)

x = np.zeros(5)
print_array(x)

x = np.full((2, 2), 1)
print_matrix(x)

#x = np.empty([2, 2])
#print(list(x.shape))


-- [ruby] -----------
$ py2rb tests/numpy/not_like.py
require 'numo/narray'
def print_matrix(data)
  data_i = []
  for i in data.to_a
    data_j = []
    for j in i
      data_j.push(("%d" % j).to_i)
    end
    data_i.push(data_j)
  end
  print(data_i)
end
def print_array(data)
  datas = []
  for i in data
    if ("%.3f" % i.abs).to_f == 0
      datas.push(("%.3f" % i.abs).to_f)
    else
      datas.push(("%.3f" % i).to_f)
    end
  end
  print(datas)
end
x = Numo::DFloat.ones(5)
print_array(x)
x = Numo::DFloat.zeros(5)
print_array(x)
x = Numo::DFloat.new([2, 2]).fill(1)
print_matrix(x)

-- [python] ---------
* tests/numpy/np_copy.py
import numpy as np

def print_array(data):
    datas = []
    for i in data:
        datas.append(i)
    print(datas)

x = np.array([1, 2, 3])
print_array(x)
y = np.copy(x)
print_array(y)
x[0] = 10
print_array(x)
print_array(y)

-- [ruby] -----------
$ py2rb tests/numpy/np_copy.py
require 'numo/narray'
def print_array(data)
  datas = []
  for i in data
    datas.push(i)
  end
  print(datas)
end
x = Numo::NArray.cast([1, 2, 3])
print_array(x)
y = (x).dup()
print_array(y)
x[0] = 10
print_array(x)
print_array(y)

-- [python] ---------
* tests/numpy/product.py
import numpy as np
x = np.prod([1.,2.])
print(x)
x = np.prod([[1.,2.],[3.,4.]])
print(x)
x = np.prod([1.,2.], dtype= np.int32)
print(int(x))
x = np.prod([1.,2.], None, np.int32)
print(int(x))
x = np.prod([1.,2.], None, dtype= np.int32)
print(int(x))
x = np.prod(dtype= np.int32, a=[1.,2.])
print(int(x))
x = np.prod([[1.,2.],[3.,4.]], axis=0)
print(list(x))
x = np.prod([[1.,2.],[3.,4.]], axis=1)
print(list(x))
x = np.prod([3.,4.], keepdims=True)
print(list(x))
a = [3.,4.]
x = np.prod(a, dtype= np.int32)
print(int(x))
-- [ruby] -----------
$ py2rb tests/numpy/product.py
require 'numo/narray'
x = Numo::NArray.cast([1.0, 2.0]).prod()
print(x)
x = Numo::NArray.cast([[1.0, 2.0], [3.0, 4.0]]).prod()
print(x)
x = Numo::Int32.cast([1.0, 2.0]).prod()
print(x.to_i)
x = Numo::NArray.cast([1.0, 2.0]).prod(axis: nil)
print(x.to_i)
x = Numo::Int32.cast([1.0, 2.0]).prod(axis: nil)
print(x.to_i)
x = Numo::Int32.cast([1.0, 2.0]).prod()
print(x.to_i)
x = Numo::NArray.cast([[1.0, 2.0], [3.0, 4.0]]).prod(axis: 0)
print(x.to_a)
x = Numo::NArray.cast([[1.0, 2.0], [3.0, 4.0]]).prod(axis: 1)
print(x.to_a)
x = Numo::NArray.cast([3.0, 4.0]).prod(keepdims: true)
print(x.to_a)
a = [3.0, 4.0]
x = Numo::Int32.cast(a).prod()
print(x.to_i)

-- [python] ---------
* tests/numpy/random_rand.py
import numpy as np

x = np.random.rand(3,3,3)
print(x.ndim)
-- [ruby] -----------
$ py2rb tests/numpy/random_rand.py
require 'numo/narray'
x = Numo::DFloat.new(3, 3, 3).rand()
print(x.ndim)

-- [python] ---------
* tests/numpy/random_randint.py
import numpy as np

def print_array(data):
    datas = []
    for i in data:
        datas.append(i)
    print(datas)

x = np.random.randint(3)
if 0 <= x <= 3:
    print('OK')
else:
    print('NG')

x = np.random.randint(1,3)
if 1 <= x <= 3:
    print('OK')
else:
    print('NG')

x = np.random.randint(1,3,(3,3))
print(x.ndim)
print_array(x.shape)

x = np.random.randint(1,3,(3,3), dtype=np.int64)
print(x.ndim)
print_array(x.shape)
-- [ruby] -----------
$ py2rb tests/numpy/random_randint.py
require 'numo/narray'
def print_array(data)
  datas = []
  for i in data
    datas.push(i)
  end
  print(datas)
end
x = Numo::Int32.new([]).rand(3)
if (0 <= x) and (x <= 3)
  print("OK")
else
  print("NG")
end
x = Numo::Int32.new([]).rand(3-(1)) + 1
if (1 <= x) and (x <= 3)
  print("OK")
else
  print("NG")
end
x = Numo::Int32.new([3, 3]).rand(3-(1)) + (1)
print(x.ndim)
print_array(x.shape)
x = Numo::Int64.new([3, 3]).rand(3-(1)) + (1)
print(x.ndim)
print_array(x.shape)

-- [python] ---------
* tests/numpy/random_random.py
import numpy as np

x = np.random.random((3,3,3))
print(x.ndim)
-- [ruby] -----------
$ py2rb tests/numpy/random_random.py
require 'numo/narray'
x = Numo::DFloat.new([3, 3, 3]).rand()
print(x.ndim)

-- [python] ---------
* tests/numpy/random_uniform.py
import numpy as np

def print_matrix(data):
    data_i = []
    for i in list(data):
        data_j = []
        for j in i:
            data_j.append(j)
        data_i.append(data_j)
    print(data_i)

x = np.random.uniform(-1, 1, (3,2))

y = np.array(x < 1, dtype=np.int)
print_matrix(y)

y = np.array(x > -1, dtype=np.int)
print_matrix(y)

x = np.random.uniform(-1, 1)
x = np.asarray(x)
print(x.ndim)

-- [ruby] -----------
$ py2rb tests/numpy/random_uniform.py
require 'numo/narray'
def print_matrix(data)
  data_i = []
  for i in data.to_a
    data_j = []
    for j in i
      data_j.push(j)
    end
    data_i.push(data_j)
  end
  print(data_i)
end
x = Numo::DFloat.new([3, 2]).rand(1-(-1)) + (-1)
y = Numo::Int64.cast(x < 1)
print_matrix(y)
y = Numo::Int64.cast(x > -1)
print_matrix(y)
x = Numo::DFloat.new().rand(1-(-1)) + -1
x = Numo::NArray.cast(x)
print(x.ndim)

-- [python] ---------
* tests/numpy/special_values.py
import numpy as np

print(str(0 * np.nan).lower())
if np.nan == np.nan: # False
    print("True")
else:
    print("False")

if np.inf > np.nan: # False
    print("True")
else:
    print("False")
print(str(np.nan - np.nan).lower())
-- [ruby] -----------
$ py2rb tests/numpy/special_values.py
require 'numo/narray'
print(((0 * Float::NAN).to_s).downcase())
if Float::NAN == Float::NAN
  print("True")
else
  print("False")
end
if Float::INFINITY > Float::NAN
  print("True")
else
  print("False")
end
print(((Float::NAN - Float::NAN).to_s).downcase())

-- [python] ---------
* tests/numpy/sqrt.py
# coding: utf-8
import numpy as np

def print_array(data):
    datas = []
    for i in data:
        if float("%.3f" % abs(i)) == 0:
            datas.append(float("%.3f" % abs(i)))
        else:
            datas.append(float("%.3f" % i))
    print(datas)

""" Math functions """

x1 = np.arange(0, 6, 0.1)


y1 = np.sqrt(x1)

for y in [x1]:
    print(len(y))
    print_array(list(y))
-- [ruby] -----------
$ py2rb tests/numpy/sqrt.py
require 'numo/narray'
def print_array(data)
  datas = []
  for i in data
    if ("%.3f" % i.abs).to_f == 0
      datas.push(("%.3f" % i.abs).to_f)
    else
      datas.push(("%.3f" % i).to_f)
    end
  end
  print(datas)
end
#  Math functions 
x1 = Numo::DFloat.new(((6-(0))/(0.1).to_f).ceil).seq(0, 0.1)
y1 = Numo::NMath.sqrt(x1)
for y in [x1]
  print(y.size)
  print_array(y.to_a)
end

-- [python] ---------
* tests/numpy/sum.py
# coding: utf-8
import numpy as np

x = np.array([1, 5])
w = np.array([2, 9])
b = 5
z = np.sum(w*x) + b
print(z)

z = (w * 3).sum()
print(z)

-- [ruby] -----------
$ py2rb tests/numpy/sum.py
require 'numo/narray'
x = Numo::NArray.cast([1, 5])
w = Numo::NArray.cast([2, 9])
b = 5
z = ((w * x).sum()) + b
print(z)
z = (w * 3).sum()
print(z)

-- [python] ---------
* tests/numpy/trigonometric_funcitons.py
# coding: utf-8
import numpy as np

def print_array(data):
    datas = []
    for i in data:
        if float("%.3f" % abs(i)) == 0:
            datas.append(float("%.3f" % abs(i)))
        else:
            datas.append(float("%.3f" % i))
    print(datas)

""" Trigonometric functions """

x1 = np.arange(0, 6, 0.1)
x2 = np.arange(-0.9, 1, 0.1)
x3 = np.arange(1, 6, 0.1)

y1 = np.sin(x1)
y2 = np.cos(x1)
y3 = np.tan(x1)

yh1 = np.sinh(x1)
yh2 = np.cosh(x1)
yh3 = np.tanh(x1)

ay1 = np.arcsin(x2)
ay2 = np.arccos(x2)
ay3 = np.arctan(x1)

ayh1 = np.arcsinh(x1)
ayh2 = np.arccosh(x3)
ayh3 = np.arctanh(x2)

for y in [x1, x2, x3, y1, y2, y3, yh1, yh2, yh3, ay1, ay2, ay3, ayh1, ayh2, ayh3]:
    print(len(y))
    print_array(list(y))
-- [ruby] -----------
$ py2rb tests/numpy/trigonometric_funcitons.py
require 'numo/narray'
def print_array(data)
  datas = []
  for i in data
    if ("%.3f" % i.abs).to_f == 0
      datas.push(("%.3f" % i.abs).to_f)
    else
      datas.push(("%.3f" % i).to_f)
    end
  end
  print(datas)
end
#  Trigonometric functions 
x1 = Numo::DFloat.new(((6-(0))/(0.1).to_f).ceil).seq(0, 0.1)
x2 = Numo::DFloat.new(((1-(-0.9))/(0.1).to_f).ceil).seq(-0.9, 0.1)
x3 = Numo::DFloat.new(((6-(1))/(0.1).to_f).ceil).seq(1, 0.1)
y1 = Numo::NMath.sin(x1)
y2 = Numo::NMath.cos(x1)
y3 = Numo::NMath.tan(x1)
yh1 = Numo::NMath.sinh(x1)
yh2 = Numo::NMath.cosh(x1)
yh3 = Numo::NMath.tanh(x1)
ay1 = Numo::NMath.asin(x2)
ay2 = Numo::NMath.acos(x2)
ay3 = Numo::NMath.atan(x1)
ayh1 = Numo::NMath.asinh(x1)
ayh2 = Numo::NMath.acosh(x3)
ayh3 = Numo::NMath.atanh(x2)
for y in [x1, x2, x3, y1, y2, y3, yh1, yh2, yh3, ay1, ay2, ay3, ayh1, ayh2, ayh3]
  print(y.size)
  print_array(y.to_a)
end

-- [python] ---------
* tests/numpy/type.py
# coding: utf-8
import numpy as np

print(np.int8)
print(np.int16)
print(np.int32)
print(np.int64)
print(np.int)
print(np.uint8)
print(np.uint16)
print(np.uint32)
print(np.uint64)
print(np.uint)
print(np.float32)
print(np.float64)
-- [ruby] -----------
$ py2rb tests/numpy/type.py
require 'numo/narray'
print(Numo::Int8)
print(Numo::Int16)
print(Numo::Int32)
print(Numo::Int64)
print(Numo::Int64)
print(Numo::UInt8)
print(Numo::UInt16)
print(Numo::UInt32)
print(Numo::UInt64)
print(Numo::UInt64)
print(Numo::SFloat)
print(Numo::DFloat)

-- [python] ---------
* tests/os/path_basename.py
import os

print(os.path.basename('foo/bar/hoge.txt'))
-- [ruby] -----------
$ py2rb tests/os/path_basename.py
print(File.basename("foo/bar/hoge.txt"))

-- [python] ---------
* tests/os/path_dirname.py
import os

print(os.path.dirname(__file__))
-- [ruby] -----------
$ py2rb tests/os/path_dirname.py
print(File.dirname(__FILE__))

-- [python] ---------
* tests/os/path_join.py
import os

print(os.path.join('foo/bar/', 'hoge.txt'))
-- [ruby] -----------
$ py2rb tests/os/path_join.py
print(File.join("foo/bar/","hoge.txt"))

-- [python] ---------
* tests/os/walk.py
import os

for dirpath, dirnames, filenames in os.walk('tests/os/testdir'):
    print('<dirpath>')
    print(dirpath)
    print('<dirnames>')
    for dirname in dirnames:
        print(dirname)
    print('<filenames>')
    for filename in filenames:
        print(filename)
-- [ruby] -----------
$ py2rb tests/os/walk.py
for (dirpath, dirnames, filenames) in PyLib.walk("tests/os/testdir")
  print("<dirpath>")
  print(dirpath)
  print("<dirnames>")
  for dirname in dirnames
    print(dirname)
  end
  print("<filenames>")
  for filename in filenames
    print(filename)
  end
end

-- [python] ---------
* tests/random/random_random.py
import random

x = random.random()

if 0 < x < 1:
    print("OK")
else:
    print("NG")
-- [ruby] -----------
$ py2rb tests/random/random_random.py
x = Random.rand()
if (0 < x) and (x < 1)
  print("OK")
else
  print("NG")
end

-- [python] ---------
* tests/six/integer_types.py
import six

if type(1) in six.integer_types:
    print('Integer')

-- [ruby] -----------
$ py2rb tests/six/integer_types.py
if [Integer].include?(1.class)
  print("Integer")
end

-- [python] ---------
* tests/six/iteritems.py
import six

a = {'a':1,'b':2,'c':3 }

items = dict()
for k, v in six.iteritems(a):
    items[k] = v

print(items['a'])
print(items['b'])
print(items['c'])
-- [ruby] -----------
$ py2rb tests/six/iteritems.py
a = {"a" => 1, "b" => 2, "c" => 3}
items = {}
for (k, v) in a.to_a
  items[k] = v
end
print(items["a"])
print(items["b"])
print(items["c"])

-- [python] ---------
* tests/six/itervalues.py
import six

foo = { 'a':'b' }

for f in six.itervalues(foo):
    print(f)

-- [ruby] -----------
$ py2rb tests/six/itervalues.py
foo = {"a" => "b"}
for f in foo.values
  print(f)
end

-- [python] ---------
* tests/six/moves.range.py
import six

xr = six.moves.range(20,40)

for x in xr:
    print(x)
-- [ruby] -----------
$ py2rb tests/six/moves.range.py
xr = 20.upto(40-1)
for x in xr
  print(x)
end

-- [python] ---------
* tests/six/py23.py
import six

if six.PY2:
    print('Python 2')
elif six.PY3:
    print('Python 3')
-- [ruby] -----------
$ py2rb tests/six/py23.py
if is_bool(false)
  print("Python 2")
else
  if is_bool(true)
    print("Python 3")
  end
end

-- [python] ---------
* tests/strings/count.py

txt = "the quick brown fox jumped over the lazy dogthe"

c = txt.count("the")
print(c)
c = txt.count("the",0,-20)
print(c)
c = txt.count("the",3)
print(c)
c = txt.count("the",4,15)
print(c)
c = txt.count("the",1,len(txt))
print(c)
c = txt.count("the",4,len(txt)-1)
print(c)
-- [ruby] -----------
$ py2rb tests/strings/count.py
txt = "the quick brown fox jumped over the lazy dogthe"
c = txt.count("the")
print(c)
c = txt.count("the", 0, -20)
print(c)
c = txt.count("the", 3)
print(c)
c = txt.count("the", 4, 15)
print(c)
c = txt.count("the", 1, txt.size)
print(c)
c = txt.count("the", 4, txt.size - 1)
print(c)

-- [python] ---------
* tests/strings/find.py

s = "the quick brown fox"
i = s.find("quick")
print(str(i))
i = s.find("dog")
print(str(i))
i = s.find("the")
print(str(i))
-- [ruby] -----------
$ py2rb tests/strings/find.py
s = "the quick brown fox"
i = s.index("quick")
print(i.to_s)
i = s.index("dog")
print(i.to_s)
i = s.index("the")
print(i.to_s)

-- [python] ---------
* tests/strings/join.py
a = ["a", "b", "c"]
print("".join(a))
print(" ".join(a))
print("x".join(a))
print("x ".join(a))
-- [ruby] -----------
$ py2rb tests/strings/join.py
a = ["a", "b", "c"]
print(a.join(""))
print(a.join(" "))
print(a.join("x"))
print(a.join("x "))

-- [python] ---------
* tests/strings/lstrip0.py


s1 = "\n\nabc\n\n\n"
s2 = "\t abc\n\t \n"
s3 = " abc "

for s in [s1,s2,s3]:
    print("original("+s+")")
    print("strip("+s.lstrip()+")")
-- [ruby] -----------
$ py2rb tests/strings/lstrip0.py
s1 = "
abc
"
s2 = "\t abc
\t 
"
s3 = " abc "
for s in [s1, s2, s3]
  print(("original(" + s) + ")")
  print(("strip(" + s.lstrip()) + ")")
end

-- [python] ---------
* tests/strings/lstrip1.py


s = "abcxyz"

print("original("+s+")")
print("strip("+s.lstrip("cba")+")")
-- [ruby] -----------
$ py2rb tests/strings/lstrip1.py
s = "abcxyz"
print(("original(" + s) + ")")
print(("strip(" + s.lstrip("cba")) + ")")

-- [python] ---------
* tests/strings/replace.py

txt = "the quick brown fox jumped over thethe lazy dog"

txt2 = txt.replace("the","a")

print(txt)
print(txt2)
-- [ruby] -----------
$ py2rb tests/strings/replace.py
txt = "the quick brown fox jumped over thethe lazy dog"
txt2 = txt.gsub("the", "a")
print(txt)
print(txt2)

-- [python] ---------
* tests/strings/rfind.py

s = "the quick brown quick the fox"
i = s.rfind("quick")
print(str(i))
i = s.rfind("dog")
print(str(i))
i = s.rfind("the")
print(str(i))
-- [ruby] -----------
$ py2rb tests/strings/rfind.py
s = "the quick brown quick the fox"
i = s.rindex("quick")
print(i.to_s)
i = s.rindex("dog")
print(i.to_s)
i = s.rindex("the")
print(i.to_s)

-- [python] ---------
* tests/strings/rstrip0.py


s1 = "abc\n\n\n"
s2 = "abc\n\t \n"
s3 = "abc "

for s in [s1,s2,s3]:
    print("original("+s+")")
    print("strip("+s.rstrip()+")")
-- [ruby] -----------
$ py2rb tests/strings/rstrip0.py
s1 = "abc
"
s2 = "abc
\t 
"
s3 = "abc "
for s in [s1, s2, s3]
  print(("original(" + s) + ")")
  print(("strip(" + s.rstrip()) + ")")
end

-- [python] ---------
* tests/strings/rstrip1.py


s = "abcxyz"

print("original("+s+")")
print("strip("+s.rstrip("yzx")+")")
-- [ruby] -----------
$ py2rb tests/strings/rstrip1.py
s = "abcxyz"
print(("original(" + s) + ")")
print(("strip(" + s.rstrip("yzx")) + ")")

-- [python] ---------
* tests/strings/split.py

s="the     quick brown fox jumped over the lazy dog"
t = s.split(" ")
for v in t:
    print(v)
r = s.split("e")
for v in r:
    print(v)
x = s.split()
for v in x:
    print(v)

# 2-arg version of split not supported
# y = s.split(" ",7)
# for v in y:
#     print v
-- [ruby] -----------
$ py2rb tests/strings/split.py
s = "the     quick brown fox jumped over the lazy dog"
t = s.split_p(" ")
for v in t
  print(v)
end
r = s.split_p("e")
for v in r
  print(v)
end
x = s.split()
for v in x
  print(v)
end

-- [python] ---------
* tests/strings/splitlines.py

txt = """
aaa

bcfdss

sdsd
wqarwqr


werewr"""

lines = txt.splitlines()

for line in lines:
    print(line)
-- [ruby] -----------
$ py2rb tests/strings/splitlines.py
txt = "
aaa
bcfdss
sdsd
wqarwqr
werewr"
lines = txt.split("
")
for line in lines
  print(line)
end

-- [python] ---------
* tests/strings/string_format_combined_simple.py
a = "well"
b = "seems to work"
c = "something else"
d = 10
f = 15

s = "%s: %d, %s: %d, %s: %d" % (a, d, b, f, c, d)
print(s)
-- [ruby] -----------
$ py2rb tests/strings/string_format_combined_simple.py
a = "well"
b = "seems to work"
c = "something else"
d = 10
f = 15
s = "%s: %d, %s: %d, %s: %d" % [a, d, b, f, c, d]
print(s)

-- [python] ---------
* tests/strings/string_format_d.py

a = 1.123456
b = 10
c = -30
d = 34
e = 123.456
f = 19892122

# form 0
s = "b=%d" % b
print(s)

# form 1
s = "b,c,d=%d+%d+%d" % (b,c,d)
print(s)

# form 2
s = "b=%(b)0d and c=%(c)d and d=%(d)d" % { 'b':b,'c':c,'d':d }
print(s)

# width,flags
s = "e=%020d e=%+d e=%20d e=%-20d (e=%- 20d)" % (e,e,e,e,e)
print(s)
-- [ruby] -----------
$ py2rb tests/strings/string_format_d.py
a = 1.123456
b = 10
c = -30
d = 34
e = 123.456
f = 19892122
s = "b=%d" % b
print(s)
s = "b,c,d=%d+%d+%d" % [b, c, d]
print(s)
s = "b=%<b>0d and c=%<c>d and d=%<d>d" % {"b": b, "c": c, "d": d}
print(s)
s = "e=%020d e=%+d e=%20d e=%-20d (e=%- 20d)" % [e, e, e, e, e]
print(s)

-- [python] ---------
* tests/strings/string_format_d_simple.py

a = 1.123456
b = 10
c = -30
d = 34
e = 123.456
f = 19892122

# form 0
s = "b=%d" % b
print(s)

# form 1
s = "b,c,d=%d+%d+%d" % (b,c,d)
print(s)

# form 2
#s = "b=%(b)0d and c=%(c)d and d=%(d)d" % { 'b':b,'c':c,'d':d }
print(s)

# width,flags
#s = "e=%020d e=%+d e=%20d e=%-20d (e=%- 20d)" % (e,e,e,e,e)
print(s)
-- [ruby] -----------
$ py2rb tests/strings/string_format_d_simple.py
a = 1.123456
b = 10
c = -30
d = 34
e = 123.456
f = 19892122
s = "b=%d" % b
print(s)
s = "b,c,d=%d+%d+%d" % [b, c, d]
print(s)
print(s)
print(s)

-- [python] ---------
* tests/strings/string_format_f_simple.py
a = 1.123456
b = 10
c = -30
d = 34
e = 123.456789
f = 892122.129899

# form 0
s = "b=%f" % a
print(s)

# form 1
s = "b,c,d=%f+%f+%f" % (a, e, f)
print(s)
-- [ruby] -----------
$ py2rb tests/strings/string_format_f_simple.py
a = 1.123456
b = 10
c = -30
d = 34
e = 123.456789
f = 892122.129899
s = "b=%f" % a
print(s)
s = "b,c,d=%f+%f+%f" % [a, e, f]
print(s)

-- [python] ---------
* tests/strings/string_format_i.py

a = 1.123456
b = 10
c = -30
d = 34
e = 123.456
f = 19892122

# form 0
s = "b=%i" % b
print(s)

# form 1
s = "b,c,d=%i+%i+%i" % (b,c,d)
print(s)

# form 2
s = "b=%(b)i and c=%(c)i and d=%(d)i" % { 'b':b,'c':c,'d':d }
print(s)

# width,flags
s = "e=%020i e=%+i e=%20i e=%-20i (e=%- 20i)" % (e,e,e,e,e)
print(s)
-- [ruby] -----------
$ py2rb tests/strings/string_format_i.py
a = 1.123456
b = 10
c = -30
d = 34
e = 123.456
f = 19892122
s = "b=%i" % b
print(s)
s = "b,c,d=%i+%i+%i" % [b, c, d]
print(s)
s = "b=%<b>i and c=%<c>i and d=%<d>i" % {"b": b, "c": c, "d": d}
print(s)
s = "e=%020i e=%+i e=%20i e=%-20i (e=%- 20i)" % [e, e, e, e, e]
print(s)

-- [python] ---------
* tests/strings/string_format_s_simple.py
a = "well"
b = "seems to work"
c = "something else"

# form 0
s = "b=%s" % a
print(s)

# form 1
s = "b,c,d=%s+%s+%s" % (a, b, c)
print(s)
-- [ruby] -----------
$ py2rb tests/strings/string_format_s_simple.py
a = "well"
b = "seems to work"
c = "something else"
s = "b=%s" % a
print(s)
s = "b,c,d=%s+%s+%s" % [a, b, c]
print(s)

-- [python] ---------
* tests/strings/string_format_u.py

a = 1.123456
b = 10
c = -30
d = 34
e = 123.456
f = 19892122

# form 0
s = "b=%u" % b
print(s)

# form 1
s = "b,c,d=%u+%u+%u" % (b,c,d)
print(s)

# form 2
s = "b=%(b)0u and c=%(c)u and d=%(d)u" % { 'b':b,'c':c,'d':d }
print(s)

# width,flags
s = "e=%020u e=%+u e=%20u e=%-20u (e=%- 20u)" % (e,e,e,e,e)
print(s)
-- [ruby] -----------
$ py2rb tests/strings/string_format_u.py
a = 1.123456
b = 10
c = -30
d = 34
e = 123.456
f = 19892122
s = "b=%u" % b
print(s)
s = "b,c,d=%u+%u+%u" % [b, c, d]
print(s)
s = "b=%<b>0u and c=%<c>u and d=%<d>u" % {"b": b, "c": c, "d": d}
print(s)
s = "e=%020u e=%+u e=%20u e=%-20u (e=%- 20u)" % [e, e, e, e, e]
print(s)

-- [python] ---------
* tests/strings/strings_in_strings.py
print(""""Hello World!" <- should 'mess' up '''thing'''?""")
-- [ruby] -----------
$ py2rb tests/strings/strings_in_strings.py
print("\"Hello World!\" <- should \'mess\' up \'\'\'thing\'\'\'?")

-- [python] ---------
* tests/strings/strip.py


s1 = "\n\nabc\n\n\n"
s2 = "\t abc\n\t \n"
s3 = " abc "

for s in [s1,s2,s3]:
    print("original("+s+")")
    print("strip("+s.strip()+")")
-- [ruby] -----------
$ py2rb tests/strings/strip.py
s1 = "
abc
"
s2 = "\t abc
\t 
"
s3 = " abc "
for s in [s1, s2, s3]
  print(("original(" + s) + ")")
  print(("strip(" + s.strip()) + ")")
end

-- [python] ---------
* tests/strings/strip1.py


s = "yxabcxyz"

print("original("+s+")")
print("strip("+s.strip("yzx")+")")
-- [ruby] -----------
$ py2rb tests/strings/strip1.py
s = "yxabcxyz"
print(("original(" + s) + ")")
print(("strip(" + s.strip("yzx")) + ")")

-- [python] ---------
* tests/strings/ulcase.py


s = "aBcddEzUh"

print(s)
s = s.upper()
print(s)
s = s.lower()
print(s)
-- [ruby] -----------
$ py2rb tests/strings/ulcase.py
s = "aBcddEzUh"
print(s)
s = s.upcase()
print(s)
s = s.downcase()
print(s)

-- [python] ---------
* tests/strings/zipstring.py

s1 = "hello"
s2 = "world"
s3 = "abcd"

s4 = list(zip(s1,s2,s3))

for item in s4:
    print("----")
    for val in item:
        print(val)
-- [ruby] -----------
$ py2rb tests/strings/zipstring.py
s1 = "hello"
s2 = "world"
s3 = "abcd"
s4 = zip_p(s1, s2, s3).to_a
for item in s4
  print("----")
  for val in item
    print(val)
  end
end

-- [python] ---------
* tests/unittest/assertAlmostEqual.py
import unittest

class TestRunnable(unittest.TestCase):

    def test_runnable(self):
        #(first, second, places=7, msg=None, delta=None)
        self.assertAlmostEqual(1.0, 1.00000001, 7)
        self.assertAlmostEqual(1.0, 1.00000001, 7, '''comment test''')
        self.assertAlmostEqual(1.0, 1.00000001, msg='''comment test''', delta=1e-8)

unittest.main()
-- [ruby] -----------
$ py2rb tests/unittest/assertAlmostEqual.py
require 'test/unit'
class TestRunnable < Test::Unit::TestCase
  def test_runnable()
    assert_in_delta(1.00000001, 1.0, 1e-1*1e-7)
    assert_in_delta(1.00000001, 1.0, 1e-1*1e-7, "comment test")
    assert_in_delta(1.00000001, 1.0, 1e-08, "comment test")
  end
end

-- [python] ---------
* tests/unittest/assertEqual.py
import unittest

class TestRunnable(unittest.TestCase):

    def test_runnable(self):
        self.assertEqual('test', 'test', '''comment test''')

unittest.main()
-- [ruby] -----------
$ py2rb tests/unittest/assertEqual.py
require 'test/unit'
class TestRunnable < Test::Unit::TestCase
  def test_runnable()
    assert_equal("test", "test", "comment test")
  end
end

-- [python] ---------
* tests/unittest/assertIn.py
import unittest

class Test_Unit(unittest.TestCase):

    def test_hoge(self):
        self.assertIn('foo', ['foo', 'bar'], 'message test')

unittest.main()
-- [ruby] -----------
$ py2rb tests/unittest/assertIn.py
require 'test/unit'
class Test_Unit < Test::Unit::TestCase
  def test_hoge()
    assert_include(["foo", "bar"], "foo", "message test")
  end
end

-- [python] ---------
* tests/unittest/assertIs.py
import unittest

class Test_Unit(unittest.TestCase):

    def test_hoge(self):
        self.assertIs('foo', 'foo', 'message test')

unittest.main()
-- [ruby] -----------
$ py2rb tests/unittest/assertIs.py
require 'test/unit'
class Test_Unit < Test::Unit::TestCase
  def test_hoge()
    assert_equal("foo", "foo", "message test")
  end
end

-- [python] ---------
* tests/unittest/assertIsInstance.py
import unittest

class Test_Unit(unittest.TestCase):

    def test_hoge(self):
        self.assertIsInstance('foo', str)
        self.assertIsInstance(1, int, 'message test')

unittest.main()
-- [ruby] -----------
$ py2rb tests/unittest/assertIsInstance.py
require 'test/unit'
class Test_Unit < Test::Unit::TestCase
  def test_hoge()
    assert_true ("foo").is_a?(String)
    assert_true (1).is_a?(Integer), "message test"
  end
end

-- [python] ---------
* tests/unittest/assertRaises.py
import unittest

class MyException(Exception):
    pass

class MyException2(Exception):
    pass

class MyException3(Exception):
    pass

class Foo:
    def test(self):
        raise MyException

class Bar:
    def test(self, a, b, c=1, d=2):
        if a != 'a':
            raise MyException

        if c == 1:
            raise MyException2
        else:
            raise MyException3

def test(a, b, c=1, d=2):
    if a != 'a':
        raise MyException

    if c == 1:
        raise MyException2
    else:
        raise MyException3

def test2():
    raise MyException

class TestRunnable(unittest.TestCase):

    def bar(self):
        assert False

    def test_runnable(self):
        ''' NameError: name 'foo' is not defined '''
        with self.assertRaises(NameError):
            foo

        foo = Foo()
        self.assertRaises(MyException, foo.test)

        bar = Bar()
        self.assertRaises(MyException, bar.test,'aa', 'b')
        self.assertRaises(MyException2, bar.test,'a', 'b')
        self.assertRaises(MyException2, bar.test,'a', 'b', d=20)
        self.assertRaises(MyException3, bar.test,'a', 'b', c=10, d=20)

        self.assertRaises(MyException, test, 'aa', 'b', c=10, d=20)
        self.assertRaises(MyException2, test, 'a', 'b')
        self.assertRaises(MyException3, test, 'a', 'b', c=10, d=20)
        self.assertRaises(MyException, test2)
        self.assertRaises(AssertionError, self.bar)

class TestRunnable2(TestRunnable):

    def test_runnable2(self):
        self.assertRaises(AssertionError, self.bar)

unittest.main()
-- [ruby] -----------
$ py2rb tests/unittest/assertRaises.py
require 'test/unit'
class MyException < Exception
  # pass
end
class MyException2 < Exception
  # pass
end
class MyException3 < Exception
  # pass
end
class Foo
  def test()
    raise MyException
  end
end
class Bar
  def test(a, b, c: 1, d: 2)
    if a != "a"
      raise MyException
    end
    if c == 1
      raise MyException2
    else
      raise MyException3
    end
  end
end
def test(a, b, c: 1, d: 2)
  if a != "a"
    raise MyException
  end
  if c == 1
    raise MyException2
  else
    raise MyException3
  end
end
def test2()
  raise MyException
end
class TestRunnable < Test::Unit::TestCase
  def bar()
    raise unless false
  end
  def test_runnable()
    #  NameError: name 'foo' is not defined 
    assert_raise(NameError) {
      foo
    }
    foo = Foo.new()
    assert_raise(MyException){foo.test()}
    bar = Bar.new()
    assert_raise(MyException){bar.test("aa", "b")}
    assert_raise(MyException2){bar.test("a", "b")}
    assert_raise(MyException2){bar.test("a", "b", d: 20)}
    assert_raise(MyException3){bar.test("a", "b", c: 10, d: 20)}
    assert_raise(MyException){test("aa", "b", c: 10, d: 20)}
    assert_raise(MyException2){test("a", "b")}
    assert_raise(MyException3){test("a", "b", c: 10, d: 20)}
    assert_raise(MyException){test2()}
    assert_raise(RuntimeError){bar()}
  end
end
class TestRunnable2 < TestRunnable
  def test_runnable2()
    assert_raise(RuntimeError){bar()}
  end
end

-- [python] ---------
* tests/unittest/assertTrue.py
import unittest

class TestRunnable(unittest.TestCase):

    def test_runnable(self):
        self.assertTrue(True, '''comment test''')

unittest.main()
-- [ruby] -----------
$ py2rb tests/unittest/assertTrue.py
require 'test/unit'
class TestRunnable < Test::Unit::TestCase
  def test_runnable()
    assert(true, "comment test")
  end
end

-- [python] ---------
* tests/unittest/class.py
import unittest

class TestRunnable(unittest.TestCase):
    pass

-- [ruby] -----------
$ py2rb tests/unittest/class.py
require 'test/unit'
class TestRunnable < Test::Unit::TestCase
  # pass
end