root/lang/perl/PlPy/trunk/PlPy/recycle/2 @ 219

use strict;
use warnings;
use Test::Base;
use lib qw/./;
use PyVM;

use XXX -dumper;

plan tests => 1*blocks;

run {
    my $block = shift;

    my $out = '';
    tie_output *STDOUT, $out;
    PyVM::run_it( $block->input );
    untie *STDOUT;
    is $out, $block->expected, $block->name;
};

# TODO:
#   [1,2,3,5][:-1] etc.
#   keyword args.

__END__

=== simple
--- input
print 3+2
--- expected
5

=== string add
--- input
print 'Boo'+'fy'
--- expected
Boofy

=== add,mul
--- input
print (3*2)+4
--- expected
10

=== binary operators
--- input
print (3+2)-4*3.14/2
--- expected
-1.28

=== binary power
--- input
print 3**4
--- expected
81

=== binary floor divide
--- input
print 25//3
--- expected
8

=== binary modulo
--- input
print 25%3
--- expected
1

=== tuple
--- input
(1,2,3)
--- expected

=== list
--- input
[1,2,3]
--- expected

=== variable
--- input
x = 'kent'
print x
--- expected
kent

=== list one
--- input
x = [1,2,3]
print x[1]
--- expected
2

=== inplace modulo
--- input
x = 58
x %= 7
print x
--- expected
2

=== binary lshift
--- input
print 1 << 3
--- expected
8

=== binary rshift
--- input
print 25352 >> 3
--- expected
3169

=== binary and
--- input
print 25352 & 522
--- expected
520

=== binary or
--- input
print 25352 | 522
--- expected
25354

=== binary xor
--- input
print 25352 ^ 522
--- expected
24834

=== unary not
--- input
print not 25453
--- expected
0

=== unary_INVERT
--- input
print ~25453
--- expected
-25454

=== if
--- input
if 3>4:
    print 'too bad'
else:
    print 'ok'
--- expected
ok

=== if
--- input
if 3<4:
    print 'ok'
else:
    print 'too bad'
--- expected
ok

=== SLICE+0
--- input
x = [1,2,3,4,5]
print x[:]
--- expected
[1, 2, 3, 4, 5]

=== SLICE+1
--- input
x = [1,2,3,4,5]
print x[2:]
--- expected
[3, 4, 5]

=== SLICE+1
--- input
x = [1]
print x[2:]
--- expected
[]

=== SLICE+2
--- input
x = [1,2,3,4,5]
print x[:2]
--- expected
[1, 2]

=== SLICE+2
--- input
x = [1]
print x[:2]
--- expected
[1]

=== SLICE+3
--- input
x = [1, 2,3,4,5,6,7,8,9,10]
print x[3:5]
--- expected
[4, 5]

=== WHILE
--- input
i=0
while i<3:
    print i
    i+=1
--- expected
0
1
2

=== string modulo
--- input
print "mixi: %s" % 'Boofy'
--- expected
mixi: Boofy

=== string modulo by tuple
--- input
print "mixi: %s, %s" % ('Boofy', 'bonnu')
--- expected
mixi: Boofy, bonnu

=== FOR
--- SKIP
--- input
for x in ['foo', 'bar', 'baz']:
    print x
--- expected
foo
bar
baz

=== simple function2
--- input
def foo(x, y, z):
    print x*5+y*3

foo(20, 4, 52)
--- expected
112

=== use function with return value
--- input
def foo(x, y, z):
    return x*5+y*2

print foo(20, 4, 52)
--- expected
108

=== use function with keyword arguments
--- input
def func(a1, a2="default a2", a3="default a3"):
    print "a1=%s" % a1
    print "a2=%s" % a2
    print "a3=%s" % a3

func(a3="custom a3", a1="custom a1")
--- expected
a1=custom a1
a2=default a2
a3=custom a3

=== use function with keyword arguments
--- ONLY
--- input
def func(a1, a2="default a2", a3="default a3"):
    print "a1=%s" % a1
    print "a2=%s" % a2
    print "a3=%s" % a3

func("custom a1", 'custom a2')
--- expected
a1=custom a1
a2=custom a2
a3=default a3


=== use function with keyword arguments
--- ONLY
--- input
def func(a1, a2="default a2", a3="default a3"):
    print "a1=%s" % a1
    print "a2=%s" % a2
    print "a3=%s" % a3

func("custom a1")
--- expected
a1=custom a1
a2=default a2
a3=default a3

=== use function with keyword arguments
--- SKIP
--- input
def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print "-- This parrot wouldn't", action,
    print "if you put", voltage, "Volts through it."
    print "-- Lovely plumage, the", type
    print "-- It's", state, "!"

parrot(action = 'VOOOOOM', voltage = 1000000)
#parrot('a thousand', state = 'pushing up the daisies')
#parrot('a million', 'bereft of life', 'jump')
#parrot(1000)
--- expected
108

=== simple function
--- SKIP
--- input
def foo(x, y):
    x*=5
    print x

x = 20
foo(x)
print x
--- expected
100

=== simple function
--- SKIP
--- input
def foo(x):
    print x*5

foo(20)
--- expected
100

=== �Ǥդ�����-- SKIP
--- input
def foo(x=4):
    print x*5

foo(20)
--- expected
100